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
97
104
static plugin *plugin_list = NULL;
98
105
99
/* Gets a existing plugin based on name,
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
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){
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;
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
136
new_plugin->environ = malloc(sizeof(char *));
154
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;
144
167
145
168
/* Append the new plugin to the list */
146
169
plugin_list = new_plugin;
147
170
return new_plugin;
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 */
182
static bool add_environment(plugin *p, const char *def){
212
__attribute__((nonnull(2)))
213
static bool add_environment(plugin *p, const char *def, bool replace){
183
214
if(p == NULL){
184
215
return false;
185
216
}
217
/* namelen = length of name of environment variable */
218
size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
/* Search for this environment variable */
220
for(char **e = p->environ; *e != NULL; e++){
221
if(strncmp(*e, def, namelen + 1) == 0){
222
/* It already exists */
223
if(replace){
224
char *new;
225
do {
226
new = realloc(*e, strlen(def) + 1);
227
} while(new == NULL and errno == EINTR);
228
if(new == NULL){
229
return false;
230
}
231
*e = new;
232
strcpy(*e, def);
233
}
234
return true;
235
}
236
}
186
237
return add_to_char_array(def, &(p->environ), &(p->envc));
187
238
}
188
239
189
240
/*
190
241
* Based on the example in the GNU LibC manual chapter 13.13 "File
191
242
* Descriptor Flags".
192
* *Note File Descriptor Flags:(libc)Descriptor Flags.
243
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
193
244
*/
194
static int set_cloexec_flag(int fd)
195
{
196
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));
197
247
/* If reading the flags failed, return error indication now. */
198
248
if(ret < 0){
199
249
return ret;
200
250
}
201
251
/* Store modified flag word in the descriptor. */
202
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
252
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
ret | FD_CLOEXEC));
203
254
}
204
255
205
256
206
257
/* Mark processes as completed when they exit, and save their exit
207
258
status. */
208
void handle_sigchld(__attribute__((unused)) int sig){
259
static void handle_sigchld(__attribute__((unused)) int sig){
260
int old_errno = errno;
209
261
while(true){
210
262
plugin *proc = plugin_list;
211
263
int status;
215
267
break;
216
268
}
217
269
if(pid == -1){
218
if (errno != ECHILD){
219
perror("waitpid");
270
if(errno == ECHILD){
271
/* No child processes */
272
break;
220
273
}
221
/* No child processes */
222
break;
274
error(0, errno, "waitpid");
223
275
}
224
276
225
277
/* A child exited, find it in process_list */
226
278
while(proc != NULL and proc->pid != pid){
227
279
proc = proc->next;
231
283
continue;
232
284
}
233
285
proc->status = status;
234
proc->completed = true;
286
proc->completed = 1;
235
287
}
288
errno = old_errno;
236
289
}
237
290
238
291
/* Prints out a password to stdout */
239
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){
240
294
ssize_t ret;
241
if(length>0 and buffer[length-1] == '\n'){
242
length--;
243
}
244
295
for(size_t written = 0; written < length; written += (size_t)ret){
245
296
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
246
297
length - written));
252
303
}
253
304
254
305
/* Removes and free a plugin from the plugin list */
306
__attribute__((nonnull))
255
307
static void free_plugin(plugin *plugin_node){
256
308
257
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
263
315
}
264
316
free(plugin_node->environ);
265
317
free(plugin_node->buffer);
266
318
267
319
/* Removes the plugin from the singly-linked list */
268
320
if(plugin_node == plugin_list){
269
321
/* First one - simple */
297
349
struct stat st;
298
350
fd_set rfds_all;
299
351
int ret, maxfd = 0;
352
ssize_t sret;
300
353
uid_t uid = 65534;
301
354
gid_t gid = 65534;
302
355
bool debug = false;
311
364
sigemptyset(&sigchld_action.sa_mask);
312
365
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
313
366
if(ret == -1){
314
perror("sigaddset");
315
exitstatus = EXIT_FAILURE;
367
error(0, errno, "sigaddset");
368
exitstatus = EX_OSERR;
316
369
goto fallback;
317
370
}
318
371
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
319
372
if(ret == -1){
320
perror("sigaction");
321
exitstatus = EXIT_FAILURE;
373
error(0, errno, "sigaction");
374
exitstatus = EX_OSERR;
322
375
goto fallback;
323
376
}
324
377
327
380
{ .name = "global-options", .key = 'g',
328
381
.arg = "OPTION[,OPTION[,...]]",
329
382
.doc = "Options passed to all plugins" },
330
{ .name = "global-envs", .key = 'e',
383
{ .name = "global-env", .key = 'G',
331
384
.arg = "VAR=value",
332
385
.doc = "Environment variable passed to all plugins" },
333
386
{ .name = "options-for", .key = 'o',
334
387
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
335
388
.doc = "Options passed only to specified plugin" },
336
{ .name = "envs-for", .key = 'f',
389
{ .name = "env-for", .key = 'E',
337
390
.arg = "PLUGIN:ENV=value",
338
391
.doc = "Environment variable passed to specified plugin" },
339
392
{ .name = "disable", .key = 'd',
340
393
.arg = "PLUGIN",
341
394
.doc = "Disable a specific plugin", .group = 1 },
395
{ .name = "enable", .key = 'e',
396
.arg = "PLUGIN",
397
.doc = "Enable a specific plugin", .group = 1 },
342
398
{ .name = "plugin-dir", .key = 128,
343
399
.arg = "DIRECTORY",
344
400
.doc = "Specify a different plugin directory", .group = 2 },
353
409
.doc = "Group ID the plugins will run as", .group = 3 },
354
410
{ .name = "debug", .key = 132,
355
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 },
356
421
{ .name = NULL }
357
422
};
358
423
359
error_t parse_opt (int key, char *arg, __attribute__((unused)) struct argp_state *state) {
360
/* Get the INPUT argument from `argp_parse', which we know is a
361
pointer to our plugin list pointer. */
362
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;
363
430
case 'g': /* --global-options */
364
if (arg != NULL){
365
char *p;
366
while((p = strsep(&arg, ",")) != NULL){
367
if(p[0] == '\0'){
368
continue;
369
}
370
if(not add_argument(getplugin(NULL), p)){
371
perror("add_argument");
372
return ARGP_ERR_UNKNOWN;
373
}
374
}
375
}
376
break;
377
case 'e': /* --global-envs */
378
if(arg == NULL){
379
break;
380
}
381
431
{
382
char *envdef = strdup(arg);
383
if(envdef == NULL){
384
break;
385
}
386
if(not add_environment(getplugin(NULL), envdef)){
387
perror("add_environment");
432
char *plugin_option;
433
while((plugin_option = strsep(&arg, ",")) != NULL){
434
if(not add_argument(getplugin(NULL), plugin_option)){
435
break;
436
}
388
437
}
389
438
}
390
439
break;
440
case 'G': /* --global-env */
441
add_environment(getplugin(NULL), arg, true);
442
break;
391
443
case 'o': /* --options-for */
392
if (arg != NULL){
393
char *p_name = strsep(&arg, ":");
394
if(p_name[0] == '\0'){
395
break;
396
}
397
char *opt = strsep(&arg, ":");
398
if(opt[0] == '\0'){
399
break;
400
}
401
if(opt != NULL){
402
char *p;
403
while((p = strsep(&opt, ",")) != NULL){
404
if(p[0] == '\0'){
405
continue;
406
}
407
if(not add_argument(getplugin(p_name), p)){
408
perror("add_argument");
409
return ARGP_ERR_UNKNOWN;
410
}
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
462
}
412
463
}
413
464
}
414
465
break;
415
case 'f': /* --envs-for */
416
if(arg == NULL){
417
break;
418
}
466
case 'E': /* --env-for */
419
467
{
420
468
char *envdef = strchr(arg, ':');
421
469
if(envdef == NULL){
422
break;
423
}
424
char *p_name = strndup(arg, (size_t) (envdef-arg));
425
if(p_name == NULL){
426
break;
427
}
470
argp_error(state, "No colon in \"%s\"", arg);
471
errno = EINVAL;
472
break;
473
}
474
*envdef = '\0';
428
475
envdef++;
429
if(not add_environment(getplugin(p_name), envdef)){
430
perror("add_environment");
476
if(arg[0] == '\0'){
477
argp_error(state, "Empty plugin name");
478
errno = EINVAL;
479
break;
431
480
}
481
add_environment(getplugin(arg), envdef, true);
432
482
}
433
483
break;
434
484
case 'd': /* --disable */
435
if (arg != NULL){
436
plugin *p = getplugin(arg);
437
if(p == NULL){
438
return ARGP_ERR_UNKNOWN;
439
}
440
p->disabled = true;
485
{
486
plugin *p = getplugin(arg);
487
if(p != NULL){
488
p->disabled = true;
489
}
490
}
491
break;
492
case 'e': /* --enable */
493
{
494
plugin *p = getplugin(arg);
495
if(p != NULL){
496
p->disabled = false;
497
}
441
498
}
442
499
break;
443
500
case 128: /* --plugin-dir */
501
free(plugindir);
444
502
plugindir = strdup(arg);
445
if(plugindir == NULL){
446
perror("strdup");
447
}
448
break;
449
case 129: /* --config-file */
503
break;
504
case 129: /* --config-file */
505
/* This is already done by parse_opt_config_file() */
506
break;
507
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;
516
break;
517
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;
526
break;
527
case 132: /* --debug */
528
debug = true;
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
*/
548
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
}
555
default:
556
return ARGP_ERR_UNKNOWN;
557
}
558
return errno; /* Set to 0 at start */
559
}
560
561
/* This option parser is the same as parse_opt() above, except it
562
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){
568
case 'g': /* --global-options */
569
case 'G': /* --global-env */
570
case 'o': /* --options-for */
571
case 'E': /* --env-for */
572
case 'd': /* --disable */
573
case 'e': /* --enable */
574
case 128: /* --plugin-dir */
575
break;
576
case 129: /* --config-file */
577
free(argfile);
450
578
argfile = strdup(arg);
451
if(argfile == NULL){
452
perror("strdup");
453
}
454
break;
579
break;
455
580
case 130: /* --userid */
456
uid = (uid_t)strtol(arg, NULL, 10);
457
break;
458
581
case 131: /* --groupid */
459
gid = (gid_t)strtol(arg, NULL, 10);
460
break;
461
582
case 132: /* --debug */
462
debug = true;
463
break;
583
case '?': /* --help */
584
case -3: /* --usage */
585
case 'V': /* --version */
464
586
case ARGP_KEY_ARG:
465
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
466
break;
467
case ARGP_KEY_END:
468
587
break;
469
588
default:
470
589
return ARGP_ERR_UNKNOWN;
471
590
}
472
return 0;
591
return errno;
473
592
}
474
593
475
struct argp argp = { .options = options, .parser = parse_opt,
476
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
594
struct argp argp = { .options = options,
595
.parser = parse_opt_config_file,
596
.args_doc = "",
477
597
.doc = "Mandos plugin runner -- Run plugins" };
478
598
479
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
480
if (ret == ARGP_ERR_UNKNOWN){
481
fprintf(stderr, "Unknown error while parsing arguments\n");
482
exitstatus = EXIT_FAILURE;
599
/* Parse using parse_opt_config_file() in order to get the custom
600
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;
483
615
goto fallback;
484
616
}
485
486
/* Opens the configfile if aviable */
487
if (argfile == NULL){
617
618
/* Reset to the normal argument parser */
619
argp.parser = parse_opt;
620
621
/* Open the configfile if available */
622
if(argfile == NULL){
488
623
conffp = fopen(AFILE, "r");
489
624
} else {
490
625
conffp = fopen(argfile, "r");
491
}
626
}
492
627
if(conffp != NULL){
493
628
char *org_line = NULL;
494
629
char *p, *arg, *new_arg, *line;
495
630
size_t size = 0;
496
ssize_t sret;
497
631
const char whitespace_delims[] = " \r\t\f\v\n";
498
632
const char comment_delim[] = "#";
499
633
500
634
custom_argc = 1;
501
635
custom_argv = malloc(sizeof(char*) * 2);
502
636
if(custom_argv == NULL){
503
perror("malloc");
504
exitstatus = EXIT_FAILURE;
637
error(0, errno, "malloc");
638
exitstatus = EX_OSERR;
505
639
goto fallback;
506
640
}
507
641
custom_argv[0] = argv[0];
508
642
custom_argv[1] = NULL;
509
510
/* for each line in the config file, strip whitespace and ignore commented text */
643
644
/* for each line in the config file, strip whitespace and ignore
645
commented text */
511
646
while(true){
512
647
sret = getline(&org_line, &size, conffp);
513
648
if(sret == -1){
514
649
break;
515
650
}
516
651
517
652
line = org_line;
518
653
arg = strsep(&line, comment_delim);
519
654
while((p = strsep(&arg, whitespace_delims)) != NULL){
522
657
}
523
658
new_arg = strdup(p);
524
659
if(new_arg == NULL){
525
perror("strdup");
526
exitstatus = EXIT_FAILURE;
660
error(0, errno, "strdup");
661
exitstatus = EX_OSERR;
527
662
free(org_line);
528
663
goto fallback;
529
664
}
532
667
custom_argv = realloc(custom_argv, sizeof(char *)
533
668
* ((unsigned int) custom_argc + 1));
534
669
if(custom_argv == NULL){
535
perror("realloc");
536
exitstatus = EXIT_FAILURE;
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
537
672
free(org_line);
538
673
goto fallback;
539
674
}
540
675
custom_argv[custom_argc-1] = new_arg;
541
custom_argv[custom_argc] = NULL;
676
custom_argv[custom_argc] = NULL;
542
677
}
543
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
}
544
687
free(org_line);
545
} else{
688
} else {
546
689
/* Check for harmful errors and go to fallback. Other errors might
547
690
not affect opening plugins */
548
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
549
perror("fopen");
550
exitstatus = EXIT_FAILURE;
691
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
692
error(0, errno, "fopen");
693
exitstatus = EX_OSERR;
551
694
goto fallback;
552
695
}
553
696
}
554
/* If there was any arguments from configuration file,
555
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 */
556
699
if(custom_argv != NULL){
557
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, NULL);
558
if (ret == ARGP_ERR_UNKNOWN){
559
fprintf(stderr, "Unknown error while parsing arguments\n");
560
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;
561
714
goto fallback;
562
715
}
563
716
}
564
717
718
/* Parse actual command line arguments, to let them override the
719
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;
734
goto fallback;
735
}
736
565
737
if(debug){
566
738
for(plugin *p = plugin_list; p != NULL; p=p->next){
567
739
fprintf(stderr, "Plugin: %s has %d arguments\n",
569
741
for(char **a = p->argv; *a != NULL; a++){
570
742
fprintf(stderr, "\tArg: %s\n", *a);
571
743
}
572
fprintf(stderr, "...and %u environment variables\n", p->envc);
744
fprintf(stderr, "...and %d environment variables\n", p->envc);
573
745
for(char **a = p->environ; *a != NULL; a++){
574
746
fprintf(stderr, "\t%s\n", *a);
575
747
}
576
748
}
577
749
}
578
579
/* Strip permissions down to nobody */
750
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
}
580
778
ret = setuid(uid);
581
if (ret == -1){
582
perror("setuid");
583
}
584
setgid(gid);
585
if (ret == -1){
586
perror("setgid");
587
}
588
589
if (plugindir == NULL){
590
dir = opendir(PDIR);
591
} else {
592
dir = opendir(plugindir);
593
}
594
595
if(dir == NULL){
596
perror("Could not open plugin dir");
597
exitstatus = EXIT_FAILURE;
598
goto fallback;
599
}
600
601
/* 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 */
602
784
{
603
int dir_fd = dirfd(dir);
604
if(dir_fd >= 0){
605
ret = set_cloexec_flag(dir_fd);
606
if(ret < 0){
607
perror("set_cloexec_flag");
608
exitstatus = EXIT_FAILURE;
609
goto fallback;
610
}
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;
611
826
}
612
827
}
613
828
614
829
FD_ZERO(&rfds_all);
615
830
616
831
/* Read and execute any executable in the plugin directory*/
617
832
while(true){
618
dirst = readdir(dir);
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
619
836
620
// All directory entries have been processed
837
/* All directory entries have been processed */
621
838
if(dirst == NULL){
622
if (errno == EBADF){
623
perror("readdir");
624
exitstatus = EXIT_FAILURE;
839
if(errno == EBADF){
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
625
842
goto fallback;
626
843
}
627
844
break;
629
846
630
847
d_name_len = strlen(dirst->d_name);
631
848
632
// Ignore dotfiles, backup files and other junk
849
/* Ignore dotfiles, backup files and other junk */
633
850
{
634
851
bool bad_name = false;
635
852
637
854
638
855
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
639
856
".dpkg-old",
857
".dpkg-bak",
640
858
".dpkg-divert", NULL };
641
859
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
642
860
size_t pre_len = strlen(*pre);
656
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
657
875
size_t suf_len = strlen(*suf);
658
876
if((d_name_len >= suf_len)
659
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
660
878
== 0)){
661
879
if(debug){
662
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
671
889
continue;
672
890
}
673
891
}
674
892
675
893
char *filename;
676
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
}
677
902
if(ret < 0){
678
perror("asprintf");
903
error(0, errno, "asprintf");
679
904
continue;
680
905
}
681
906
682
ret = stat(filename, &st);
683
if (ret == -1){
684
perror("stat");
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
908
if(ret == -1){
909
error(0, errno, "stat");
685
910
free(filename);
686
911
continue;
687
912
}
688
913
689
914
/* Ignore non-executable files */
690
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)){
691
917
if(debug){
692
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
693
919
" with bad type or mode\n", filename);
698
924
699
925
plugin *p = getplugin(dirst->d_name);
700
926
if(p == NULL){
701
perror("getplugin");
927
error(0, errno, "getplugin");
702
928
free(filename);
703
929
continue;
704
930
}
716
942
if(g != NULL){
717
943
for(char **a = g->argv + 1; *a != NULL; a++){
718
944
if(not add_argument(p, *a)){
719
perror("add_argument");
945
error(0, errno, "add_argument");
720
946
}
721
947
}
722
948
/* Add global environment variables */
723
949
for(char **e = g->environ; *e != NULL; e++){
724
if(not add_environment(p, *e)){
725
perror("add_environment");
950
if(not add_environment(p, *e, false)){
951
error(0, errno, "add_environment");
726
952
}
727
953
}
728
954
}
732
958
process, too. */
733
959
if(p->environ[0] != NULL){
734
960
for(char **e = environ; *e != NULL; e++){
735
char *copy = strdup(*e);
736
if(copy == NULL){
737
perror("strdup");
738
continue;
739
}
740
if(not add_environment(p, copy)){
741
perror("add_environment");
961
if(not add_environment(p, *e, false)){
962
error(0, errno, "add_environment");
742
963
}
743
964
}
744
965
}
745
966
746
967
int pipefd[2];
747
ret = pipe(pipefd);
748
if (ret == -1){
749
perror("pipe");
750
exitstatus = EXIT_FAILURE;
968
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
969
if(ret == -1){
970
error(0, errno, "pipe");
971
exitstatus = EX_OSERR;
751
972
goto fallback;
752
973
}
753
974
/* Ask OS to automatic close the pipe on exec */
754
975
ret = set_cloexec_flag(pipefd[0]);
755
976
if(ret < 0){
756
perror("set_cloexec_flag");
757
exitstatus = EXIT_FAILURE;
977
error(0, errno, "set_cloexec_flag");
978
exitstatus = EX_OSERR;
758
979
goto fallback;
759
980
}
760
981
ret = set_cloexec_flag(pipefd[1]);
761
982
if(ret < 0){
762
perror("set_cloexec_flag");
763
exitstatus = EXIT_FAILURE;
983
error(0, errno, "set_cloexec_flag");
984
exitstatus = EX_OSERR;
764
985
goto fallback;
765
986
}
766
987
/* Block SIGCHLD until process is safely in process list */
767
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));
768
991
if(ret < 0){
769
perror("sigprocmask");
770
exitstatus = EXIT_FAILURE;
992
error(0, errno, "sigprocmask");
993
exitstatus = EX_OSERR;
771
994
goto fallback;
772
995
}
773
// Starting a new process to be watched
774
pid_t pid = fork();
996
/* Starting a new process to be watched */
997
pid_t pid;
998
do {
999
pid = fork();
1000
} while(pid == -1 and errno == EINTR);
775
1001
if(pid == -1){
776
perror("fork");
777
exitstatus = EXIT_FAILURE;
1002
error(0, errno, "fork");
1003
exitstatus = EX_OSERR;
778
1004
goto fallback;
779
1005
}
780
1006
if(pid == 0){
781
1007
/* this is the child process */
782
1008
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
783
1009
if(ret < 0){
784
perror("sigaction");
785
_exit(EXIT_FAILURE);
1010
error(0, errno, "sigaction");
1011
_exit(EX_OSERR);
786
1012
}
787
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1013
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
788
1014
if(ret < 0){
789
perror("sigprocmask");
790
_exit(EXIT_FAILURE);
1015
error(0, errno, "sigprocmask");
1016
_exit(EX_OSERR);
791
1017
}
792
1018
793
1019
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
794
1020
if(ret == -1){
795
perror("dup2");
796
_exit(EXIT_FAILURE);
1021
error(0, errno, "dup2");
1022
_exit(EX_OSERR);
797
1023
}
798
1024
799
1025
if(dirfd(dir) < 0){
803
1029
}
804
1030
if(p->environ[0] == NULL){
805
1031
if(execv(filename, p->argv) < 0){
806
perror("execv");
807
_exit(EXIT_FAILURE);
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
808
1034
}
809
1035
} else {
810
1036
if(execve(filename, p->argv, p->environ) < 0){
811
perror("execve");
812
_exit(EXIT_FAILURE);
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
813
1039
}
814
1040
}
815
1041
/* no return */
816
1042
}
817
1043
/* Parent process */
818
close(pipefd[1]); /* Close unused write end of pipe */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
819
1046
free(filename);
820
1047
plugin *new_plugin = getplugin(dirst->d_name);
821
if (new_plugin == NULL){
822
perror("getplugin");
823
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)));
824
1053
if(ret < 0){
825
perror("sigprocmask");
1054
error(0, errno, "sigprocmask");
826
1055
}
827
exitstatus = EXIT_FAILURE;
1056
exitstatus = EX_OSERR;
828
1057
goto fallback;
829
1058
}
830
1059
833
1062
834
1063
/* Unblock SIGCHLD so signal handler can be run if this process
835
1064
has already completed */
836
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));
837
1068
if(ret < 0){
838
perror("sigprocmask");
839
exitstatus = EXIT_FAILURE;
1069
error(0, errno, "sigprocmask");
1070
exitstatus = EX_OSERR;
840
1071
goto fallback;
841
1072
}
842
1073
843
FD_SET(new_plugin->fd, &rfds_all);
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
844
1076
845
if (maxfd < new_plugin->fd){
1077
if(maxfd < new_plugin->fd){
846
1078
maxfd = new_plugin->fd;
847
1079
}
848
849
1080
}
850
1081
851
closedir(dir);
1082
TEMP_FAILURE_RETRY(closedir(dir));
852
1083
dir = NULL;
853
1084
free_plugin(getplugin(NULL));
1085
854
1086
for(plugin *p = plugin_list; p != NULL; p = p->next){
855
1087
if(p->pid != 0){
856
1088
break;
861
1093
free_plugin_list();
862
1094
}
863
1095
}
864
1096
865
1097
/* Main loop while running plugins exist */
866
1098
while(plugin_list){
867
1099
fd_set rfds = rfds_all;
868
1100
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
869
if (select_ret == -1){
870
perror("select");
871
exitstatus = EXIT_FAILURE;
1101
if(select_ret == -1 and errno != EINTR){
1102
error(0, errno, "select");
1103
exitstatus = EX_OSERR;
872
1104
goto fallback;
873
1105
}
874
1106
/* OK, now either a process completed, or something can be read
875
1107
from one of them */
876
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
1108
for(plugin *proc = plugin_list; proc != NULL;){
877
1109
/* Is this process completely done? */
878
if(proc->eof and proc->completed){
1110
if(proc->completed and proc->eof){
879
1111
/* Only accept the plugin output if it exited cleanly */
880
1112
if(not WIFEXITED(proc->status)
881
1113
or WEXITSTATUS(proc->status) != 0){
882
1114
/* Bad exit by plugin */
883
1115
884
1116
if(debug){
885
1117
if(WIFEXITED(proc->status)){
886
fprintf(stderr, "Plugin %u exited with status %d\n",
887
(unsigned int) (proc->pid),
1118
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1119
" status %d\n", proc->name,
1120
(intmax_t) (proc->pid),
888
1121
WEXITSTATUS(proc->status));
889
} else if(WIFSIGNALED(proc->status)) {
890
fprintf(stderr, "Plugin %u killed by signal %d\n",
891
(unsigned int) (proc->pid),
892
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)));
893
1128
} else if(WCOREDUMP(proc->status)){
894
fprintf(stderr, "Plugin %d dumped core\n",
895
(unsigned int) (proc->pid));
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
" core\n", proc->name, (intmax_t) (proc->pid));
896
1131
}
897
1132
}
898
1133
899
1134
/* Remove the plugin */
900
FD_CLR(proc->fd, &rfds_all);
901
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
1137
902
1138
/* Block signal while modifying process_list */
903
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));
904
1143
if(ret < 0){
905
perror("sigprocmask");
906
exitstatus = EXIT_FAILURE;
1144
error(0, errno, "sigprocmask");
1145
exitstatus = EX_OSERR;
907
1146
goto fallback;
908
1147
}
1148
1149
plugin *next_plugin = proc->next;
909
1150
free_plugin(proc);
1151
proc = next_plugin;
1152
910
1153
/* We are done modifying process list, so unblock signal */
911
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
912
NULL);
1154
ret = (int)(TEMP_FAILURE_RETRY
1155
(sigprocmask(SIG_UNBLOCK,
1156
&sigchld_action.sa_mask, NULL)));
913
1157
if(ret < 0){
914
perror("sigprocmask");
915
exitstatus = EXIT_FAILURE;
1158
error(0, errno, "sigprocmask");
1159
exitstatus = EX_OSERR;
916
1160
goto fallback;
917
1161
}
918
1162
919
1163
if(plugin_list == NULL){
920
1164
break;
921
1165
}
1166
922
1167
continue;
923
1168
}
924
1169
925
1170
/* This process exited nicely, so print its buffer */
926
1171
927
1172
bool bret = print_out_password(proc->buffer,
928
1173
proc->buffer_length);
929
1174
if(not bret){
930
perror("print_out_password");
931
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "print_out_password");
1176
exitstatus = EX_IOERR;
932
1177
}
933
1178
goto fallback;
934
1179
}
935
1180
936
1181
/* This process has not completed. Does it have any output? */
937
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 */
938
1185
/* This process had nothing to say at this time */
1186
proc = proc->next;
939
1187
continue;
940
1188
}
941
1189
/* Before reading, make the process' data buffer large enough */
942
1190
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
943
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
944
1192
+ (size_t) BUFFER_SIZE);
945
if (proc->buffer == NULL){
946
perror("malloc");
947
exitstatus = EXIT_FAILURE;
1193
if(proc->buffer == NULL){
1194
error(0, errno, "malloc");
1195
exitstatus = EX_OSERR;
948
1196
goto fallback;
949
1197
}
950
1198
proc->buffer_size += BUFFER_SIZE;
951
1199
}
952
1200
/* Read from the process */
953
ret = read(proc->fd, proc->buffer + proc->buffer_length,
954
BUFFER_SIZE);
955
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){
956
1206
/* Read error from this process; ignore the error */
1207
proc = proc->next;
957
1208
continue;
958
1209
}
959
if(ret == 0){
1210
if(sret == 0){
960
1211
/* got EOF */
961
1212
proc->eof = true;
962
1213
} else {
963
proc->buffer_length += (size_t) ret;
1214
proc->buffer_length += (size_t) sret;
964
1215
}
965
1216
}
966
1217
}
967
968
1218
1219
969
1220
fallback:
970
1221
971
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1222
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1223
and exitstatus != EX_OK)){
972
1224
/* Fallback if all plugins failed, none are found or an error
973
1225
occured */
974
1226
bool bret;
975
1227
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
976
1228
char *passwordbuffer = getpass("Password: ");
977
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);
978
1236
if(not bret){
979
perror("print_out_password");
980
exitstatus = EXIT_FAILURE;
1237
error(0, errno, "print_out_password");
1238
exitstatus = EX_IOERR;
981
1239
}
982
1240
}
983
1241
984
1242
/* Restore old signal handler */
985
1243
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
986
1244
if(ret == -1){
987
perror("sigaction");
988
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "sigaction");
1246
exitstatus = EX_OSERR;
989
1247
}
990
1248
991
1249
if(custom_argv != NULL){
992
1250
for(char **arg = custom_argv+1; *arg != NULL; arg++){
993
1251
free(*arg);
999
1257
closedir(dir);
1000
1258
}
1001
1259
1002
/* Free the process list and kill the processes */
1260
/* Kill the processes */
1003
1261
for(plugin *p = plugin_list; p != NULL; p = p->next){
1004
1262
if(p->pid != 0){
1005
1263
close(p->fd);
1006
1264
ret = kill(p->pid, SIGTERM);
1007
1265
if(ret == -1 and errno != ESRCH){
1008
1266
/* Set-uid proccesses might not get closed */
1009
perror("kill");
1267
error(0, errno, "kill");
1010
1268
}
1011
1269
}
1012
1270
}
1013
1271
1014
1272
/* Wait for any remaining child processes to terminate */
1015
do{
1273
do {
1016
1274
ret = wait(NULL);
1017
1275
} while(ret >= 0);
1018
1276
if(errno != ECHILD){
1019
perror("wait");
1277
error(0, errno, "wait");
1020
1278
}
1021
1279
1022
1280
free_plugin_list();
1023
1281
1024
1282
free(plugindir);
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0