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))
360
struct argp_state *state) {
361
/* Get the INPUT argument from `argp_parse', which we know is a
362
pointer to our plugin list pointer. */
363
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;
364
430
case 'g': /* --global-options */
365
if (arg != NULL){
366
char *p;
367
while((p = strsep(&arg, ",")) != NULL){
368
if(p[0] == '\0'){
369
continue;
370
}
371
if(not add_argument(getplugin(NULL), p)){
372
perror("add_argument");
373
return ARGP_ERR_UNKNOWN;
374
}
375
}
376
}
377
break;
378
case 'e': /* --global-envs */
379
if(arg == NULL){
380
break;
381
}
382
431
{
383
char *envdef = strdup(arg);
384
if(envdef == NULL){
385
break;
386
}
387
if(not add_environment(getplugin(NULL), envdef)){
388
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
}
389
437
}
390
438
}
391
439
break;
440
case 'G': /* --global-env */
441
add_environment(getplugin(NULL), arg, true);
442
break;
392
443
case 'o': /* --options-for */
393
if (arg != NULL){
394
char *p_name = strsep(&arg, ":");
395
if(p_name[0] == '\0'){
396
break;
397
}
398
char *opt = strsep(&arg, ":");
399
if(opt[0] == '\0'){
400
break;
401
}
402
if(opt != NULL){
403
char *p;
404
while((p = strsep(&opt, ",")) != NULL){
405
if(p[0] == '\0'){
406
continue;
407
}
408
if(not add_argument(getplugin(p_name), p)){
409
perror("add_argument");
410
return ARGP_ERR_UNKNOWN;
411
}
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;
412
462
}
413
463
}
414
464
}
415
465
break;
416
case 'f': /* --envs-for */
417
if(arg == NULL){
418
break;
419
}
466
case 'E': /* --env-for */
420
467
{
421
468
char *envdef = strchr(arg, ':');
422
469
if(envdef == NULL){
423
break;
424
}
425
char *p_name = strndup(arg, (size_t) (envdef-arg));
426
if(p_name == NULL){
427
break;
428
}
470
argp_error(state, "No colon in \"%s\"", arg);
471
errno = EINVAL;
472
break;
473
}
474
*envdef = '\0';
429
475
envdef++;
430
if(not add_environment(getplugin(p_name), envdef)){
431
perror("add_environment");
476
if(arg[0] == '\0'){
477
argp_error(state, "Empty plugin name");
478
errno = EINVAL;
479
break;
432
480
}
481
add_environment(getplugin(arg), envdef, true);
433
482
}
434
483
break;
435
484
case 'd': /* --disable */
436
if (arg != NULL){
437
plugin *p = getplugin(arg);
438
if(p == NULL){
439
return ARGP_ERR_UNKNOWN;
440
}
441
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
}
442
498
}
443
499
break;
444
500
case 128: /* --plugin-dir */
501
free(plugindir);
445
502
plugindir = strdup(arg);
446
if(plugindir == NULL){
447
perror("strdup");
448
}
449
break;
450
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);
451
578
argfile = strdup(arg);
452
if(argfile == NULL){
453
perror("strdup");
454
}
455
break;
579
break;
456
580
case 130: /* --userid */
457
uid = (uid_t)strtol(arg, NULL, 10);
458
break;
459
581
case 131: /* --groupid */
460
gid = (gid_t)strtol(arg, NULL, 10);
461
break;
462
582
case 132: /* --debug */
463
debug = true;
464
break;
583
case '?': /* --help */
584
case -3: /* --usage */
585
case 'V': /* --version */
465
586
case ARGP_KEY_ARG:
466
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
467
break;
468
case ARGP_KEY_END:
469
587
break;
470
588
default:
471
589
return ARGP_ERR_UNKNOWN;
472
590
}
473
return 0;
591
return errno;
474
592
}
475
593
476
struct argp argp = { .options = options, .parser = parse_opt,
477
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
594
struct argp argp = { .options = options,
595
.parser = parse_opt_config_file,
596
.args_doc = "",
478
597
.doc = "Mandos plugin runner -- Run plugins" };
479
598
480
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
481
if (ret == ARGP_ERR_UNKNOWN){
482
fprintf(stderr, "Unknown error while parsing arguments\n");
483
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;
484
615
goto fallback;
485
616
}
486
487
/* Opens the configfile if aviable */
488
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){
489
623
conffp = fopen(AFILE, "r");
490
624
} else {
491
625
conffp = fopen(argfile, "r");
492
}
626
}
493
627
if(conffp != NULL){
494
628
char *org_line = NULL;
495
629
char *p, *arg, *new_arg, *line;
496
630
size_t size = 0;
497
ssize_t sret;
498
631
const char whitespace_delims[] = " \r\t\f\v\n";
499
632
const char comment_delim[] = "#";
500
633
501
634
custom_argc = 1;
502
635
custom_argv = malloc(sizeof(char*) * 2);
503
636
if(custom_argv == NULL){
504
perror("malloc");
505
exitstatus = EXIT_FAILURE;
637
error(0, errno, "malloc");
638
exitstatus = EX_OSERR;
506
639
goto fallback;
507
640
}
508
641
custom_argv[0] = argv[0];
509
642
custom_argv[1] = NULL;
510
643
511
644
/* for each line in the config file, strip whitespace and ignore
512
645
commented text */
513
646
while(true){
515
648
if(sret == -1){
516
649
break;
517
650
}
518
651
519
652
line = org_line;
520
653
arg = strsep(&line, comment_delim);
521
654
while((p = strsep(&arg, whitespace_delims)) != NULL){
524
657
}
525
658
new_arg = strdup(p);
526
659
if(new_arg == NULL){
527
perror("strdup");
528
exitstatus = EXIT_FAILURE;
660
error(0, errno, "strdup");
661
exitstatus = EX_OSERR;
529
662
free(org_line);
530
663
goto fallback;
531
664
}
534
667
custom_argv = realloc(custom_argv, sizeof(char *)
535
668
* ((unsigned int) custom_argc + 1));
536
669
if(custom_argv == NULL){
537
perror("realloc");
538
exitstatus = EXIT_FAILURE;
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
539
672
free(org_line);
540
673
goto fallback;
541
674
}
542
675
custom_argv[custom_argc-1] = new_arg;
543
custom_argv[custom_argc] = NULL;
676
custom_argv[custom_argc] = NULL;
544
677
}
545
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
}
546
687
free(org_line);
547
} else{
688
} else {
548
689
/* Check for harmful errors and go to fallback. Other errors might
549
690
not affect opening plugins */
550
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
551
perror("fopen");
552
exitstatus = EXIT_FAILURE;
691
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
692
error(0, errno, "fopen");
693
exitstatus = EX_OSERR;
553
694
goto fallback;
554
695
}
555
696
}
556
/* If there was any arguments from configuration file,
557
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 */
558
699
if(custom_argv != NULL){
559
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, NULL);
560
if (ret == ARGP_ERR_UNKNOWN){
561
fprintf(stderr, "Unknown error while parsing arguments\n");
562
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;
563
714
goto fallback;
564
715
}
565
716
}
566
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
567
737
if(debug){
568
738
for(plugin *p = plugin_list; p != NULL; p=p->next){
569
739
fprintf(stderr, "Plugin: %s has %d arguments\n",
571
741
for(char **a = p->argv; *a != NULL; a++){
572
742
fprintf(stderr, "\tArg: %s\n", *a);
573
743
}
574
fprintf(stderr, "...and %u environment variables\n", p->envc);
744
fprintf(stderr, "...and %d environment variables\n", p->envc);
575
745
for(char **a = p->environ; *a != NULL; a++){
576
746
fprintf(stderr, "\t%s\n", *a);
577
747
}
578
748
}
579
749
}
580
581
/* 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
}
582
778
ret = setuid(uid);
583
if (ret == -1){
584
perror("setuid");
585
}
586
setgid(gid);
587
if (ret == -1){
588
perror("setgid");
589
}
590
591
if (plugindir == NULL){
592
dir = opendir(PDIR);
593
} else {
594
dir = opendir(plugindir);
595
}
596
597
if(dir == NULL){
598
perror("Could not open plugin dir");
599
exitstatus = EXIT_FAILURE;
600
goto fallback;
601
}
602
603
/* 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 */
604
784
{
605
int dir_fd = dirfd(dir);
606
if(dir_fd >= 0){
607
ret = set_cloexec_flag(dir_fd);
608
if(ret < 0){
609
perror("set_cloexec_flag");
610
exitstatus = EXIT_FAILURE;
611
goto fallback;
612
}
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;
613
826
}
614
827
}
615
828
616
829
FD_ZERO(&rfds_all);
617
830
618
831
/* Read and execute any executable in the plugin directory*/
619
832
while(true){
620
dirst = readdir(dir);
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
621
836
622
// All directory entries have been processed
837
/* All directory entries have been processed */
623
838
if(dirst == NULL){
624
if (errno == EBADF){
625
perror("readdir");
626
exitstatus = EXIT_FAILURE;
839
if(errno == EBADF){
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
627
842
goto fallback;
628
843
}
629
844
break;
631
846
632
847
d_name_len = strlen(dirst->d_name);
633
848
634
// Ignore dotfiles, backup files and other junk
849
/* Ignore dotfiles, backup files and other junk */
635
850
{
636
851
bool bad_name = false;
637
852
639
854
640
855
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
641
856
".dpkg-old",
857
".dpkg-bak",
642
858
".dpkg-divert", NULL };
643
859
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
644
860
size_t pre_len = strlen(*pre);
658
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
659
875
size_t suf_len = strlen(*suf);
660
876
if((d_name_len >= suf_len)
661
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
662
878
== 0)){
663
879
if(debug){
664
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
673
889
continue;
674
890
}
675
891
}
676
892
677
893
char *filename;
678
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
}
679
902
if(ret < 0){
680
perror("asprintf");
903
error(0, errno, "asprintf");
681
904
continue;
682
905
}
683
906
684
ret = stat(filename, &st);
685
if (ret == -1){
686
perror("stat");
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
908
if(ret == -1){
909
error(0, errno, "stat");
687
910
free(filename);
688
911
continue;
689
912
}
690
913
691
914
/* Ignore non-executable files */
692
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)){
693
917
if(debug){
694
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
695
919
" with bad type or mode\n", filename);
700
924
701
925
plugin *p = getplugin(dirst->d_name);
702
926
if(p == NULL){
703
perror("getplugin");
927
error(0, errno, "getplugin");
704
928
free(filename);
705
929
continue;
706
930
}
718
942
if(g != NULL){
719
943
for(char **a = g->argv + 1; *a != NULL; a++){
720
944
if(not add_argument(p, *a)){
721
perror("add_argument");
945
error(0, errno, "add_argument");
722
946
}
723
947
}
724
948
/* Add global environment variables */
725
949
for(char **e = g->environ; *e != NULL; e++){
726
if(not add_environment(p, *e)){
727
perror("add_environment");
950
if(not add_environment(p, *e, false)){
951
error(0, errno, "add_environment");
728
952
}
729
953
}
730
954
}
734
958
process, too. */
735
959
if(p->environ[0] != NULL){
736
960
for(char **e = environ; *e != NULL; e++){
737
char *copy = strdup(*e);
738
if(copy == NULL){
739
perror("strdup");
740
continue;
741
}
742
if(not add_environment(p, copy)){
743
perror("add_environment");
961
if(not add_environment(p, *e, false)){
962
error(0, errno, "add_environment");
744
963
}
745
964
}
746
965
}
747
966
748
967
int pipefd[2];
749
ret = pipe(pipefd);
750
if (ret == -1){
751
perror("pipe");
752
exitstatus = EXIT_FAILURE;
968
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
969
if(ret == -1){
970
error(0, errno, "pipe");
971
exitstatus = EX_OSERR;
753
972
goto fallback;
754
973
}
755
974
/* Ask OS to automatic close the pipe on exec */
756
975
ret = set_cloexec_flag(pipefd[0]);
757
976
if(ret < 0){
758
perror("set_cloexec_flag");
759
exitstatus = EXIT_FAILURE;
977
error(0, errno, "set_cloexec_flag");
978
exitstatus = EX_OSERR;
760
979
goto fallback;
761
980
}
762
981
ret = set_cloexec_flag(pipefd[1]);
763
982
if(ret < 0){
764
perror("set_cloexec_flag");
765
exitstatus = EXIT_FAILURE;
983
error(0, errno, "set_cloexec_flag");
984
exitstatus = EX_OSERR;
766
985
goto fallback;
767
986
}
768
987
/* Block SIGCHLD until process is safely in process list */
769
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));
770
991
if(ret < 0){
771
perror("sigprocmask");
772
exitstatus = EXIT_FAILURE;
992
error(0, errno, "sigprocmask");
993
exitstatus = EX_OSERR;
773
994
goto fallback;
774
995
}
775
// Starting a new process to be watched
776
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);
777
1001
if(pid == -1){
778
perror("fork");
779
exitstatus = EXIT_FAILURE;
1002
error(0, errno, "fork");
1003
exitstatus = EX_OSERR;
780
1004
goto fallback;
781
1005
}
782
1006
if(pid == 0){
783
1007
/* this is the child process */
784
1008
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
785
1009
if(ret < 0){
786
perror("sigaction");
787
_exit(EXIT_FAILURE);
1010
error(0, errno, "sigaction");
1011
_exit(EX_OSERR);
788
1012
}
789
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1013
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
790
1014
if(ret < 0){
791
perror("sigprocmask");
792
_exit(EXIT_FAILURE);
1015
error(0, errno, "sigprocmask");
1016
_exit(EX_OSERR);
793
1017
}
794
1018
795
1019
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
796
1020
if(ret == -1){
797
perror("dup2");
798
_exit(EXIT_FAILURE);
1021
error(0, errno, "dup2");
1022
_exit(EX_OSERR);
799
1023
}
800
1024
801
1025
if(dirfd(dir) < 0){
805
1029
}
806
1030
if(p->environ[0] == NULL){
807
1031
if(execv(filename, p->argv) < 0){
808
perror("execv");
809
_exit(EXIT_FAILURE);
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
810
1034
}
811
1035
} else {
812
1036
if(execve(filename, p->argv, p->environ) < 0){
813
perror("execve");
814
_exit(EXIT_FAILURE);
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
815
1039
}
816
1040
}
817
1041
/* no return */
818
1042
}
819
1043
/* Parent process */
820
close(pipefd[1]); /* Close unused write end of pipe */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
821
1046
free(filename);
822
1047
plugin *new_plugin = getplugin(dirst->d_name);
823
if (new_plugin == NULL){
824
perror("getplugin");
825
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)));
826
1053
if(ret < 0){
827
perror("sigprocmask");
1054
error(0, errno, "sigprocmask");
828
1055
}
829
exitstatus = EXIT_FAILURE;
1056
exitstatus = EX_OSERR;
830
1057
goto fallback;
831
1058
}
832
1059
835
1062
836
1063
/* Unblock SIGCHLD so signal handler can be run if this process
837
1064
has already completed */
838
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));
839
1068
if(ret < 0){
840
perror("sigprocmask");
841
exitstatus = EXIT_FAILURE;
1069
error(0, errno, "sigprocmask");
1070
exitstatus = EX_OSERR;
842
1071
goto fallback;
843
1072
}
844
1073
845
FD_SET(new_plugin->fd, &rfds_all);
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
846
1076
847
if (maxfd < new_plugin->fd){
1077
if(maxfd < new_plugin->fd){
848
1078
maxfd = new_plugin->fd;
849
1079
}
850
851
1080
}
852
1081
853
closedir(dir);
1082
TEMP_FAILURE_RETRY(closedir(dir));
854
1083
dir = NULL;
855
1084
free_plugin(getplugin(NULL));
1085
856
1086
for(plugin *p = plugin_list; p != NULL; p = p->next){
857
1087
if(p->pid != 0){
858
1088
break;
863
1093
free_plugin_list();
864
1094
}
865
1095
}
866
1096
867
1097
/* Main loop while running plugins exist */
868
1098
while(plugin_list){
869
1099
fd_set rfds = rfds_all;
870
1100
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
871
if (select_ret == -1){
872
perror("select");
873
exitstatus = EXIT_FAILURE;
1101
if(select_ret == -1 and errno != EINTR){
1102
error(0, errno, "select");
1103
exitstatus = EX_OSERR;
874
1104
goto fallback;
875
1105
}
876
1106
/* OK, now either a process completed, or something can be read
877
1107
from one of them */
878
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
1108
for(plugin *proc = plugin_list; proc != NULL;){
879
1109
/* Is this process completely done? */
880
if(proc->eof and proc->completed){
1110
if(proc->completed and proc->eof){
881
1111
/* Only accept the plugin output if it exited cleanly */
882
1112
if(not WIFEXITED(proc->status)
883
1113
or WEXITSTATUS(proc->status) != 0){
884
1114
/* Bad exit by plugin */
885
1115
886
1116
if(debug){
887
1117
if(WIFEXITED(proc->status)){
888
fprintf(stderr, "Plugin %u exited with status %d\n",
889
(unsigned int) (proc->pid),
1118
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1119
" status %d\n", proc->name,
1120
(intmax_t) (proc->pid),
890
1121
WEXITSTATUS(proc->status));
891
} else if(WIFSIGNALED(proc->status)) {
892
fprintf(stderr, "Plugin %u killed by signal %d\n",
893
(unsigned int) (proc->pid),
894
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)));
895
1128
} else if(WCOREDUMP(proc->status)){
896
fprintf(stderr, "Plugin %d dumped core\n",
897
(unsigned int) (proc->pid));
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
" core\n", proc->name, (intmax_t) (proc->pid));
898
1131
}
899
1132
}
900
1133
901
1134
/* Remove the plugin */
902
FD_CLR(proc->fd, &rfds_all);
903
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
1137
904
1138
/* Block signal while modifying process_list */
905
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));
906
1143
if(ret < 0){
907
perror("sigprocmask");
908
exitstatus = EXIT_FAILURE;
1144
error(0, errno, "sigprocmask");
1145
exitstatus = EX_OSERR;
909
1146
goto fallback;
910
1147
}
1148
1149
plugin *next_plugin = proc->next;
911
1150
free_plugin(proc);
1151
proc = next_plugin;
1152
912
1153
/* We are done modifying process list, so unblock signal */
913
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
914
NULL);
1154
ret = (int)(TEMP_FAILURE_RETRY
1155
(sigprocmask(SIG_UNBLOCK,
1156
&sigchld_action.sa_mask, NULL)));
915
1157
if(ret < 0){
916
perror("sigprocmask");
917
exitstatus = EXIT_FAILURE;
1158
error(0, errno, "sigprocmask");
1159
exitstatus = EX_OSERR;
918
1160
goto fallback;
919
1161
}
920
1162
921
1163
if(plugin_list == NULL){
922
1164
break;
923
1165
}
1166
924
1167
continue;
925
1168
}
926
1169
927
1170
/* This process exited nicely, so print its buffer */
928
1171
929
1172
bool bret = print_out_password(proc->buffer,
930
1173
proc->buffer_length);
931
1174
if(not bret){
932
perror("print_out_password");
933
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "print_out_password");
1176
exitstatus = EX_IOERR;
934
1177
}
935
1178
goto fallback;
936
1179
}
937
1180
938
1181
/* This process has not completed. Does it have any output? */
939
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 */
940
1185
/* This process had nothing to say at this time */
1186
proc = proc->next;
941
1187
continue;
942
1188
}
943
1189
/* Before reading, make the process' data buffer large enough */
944
1190
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
945
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
946
1192
+ (size_t) BUFFER_SIZE);
947
if (proc->buffer == NULL){
948
perror("malloc");
949
exitstatus = EXIT_FAILURE;
1193
if(proc->buffer == NULL){
1194
error(0, errno, "malloc");
1195
exitstatus = EX_OSERR;
950
1196
goto fallback;
951
1197
}
952
1198
proc->buffer_size += BUFFER_SIZE;
953
1199
}
954
1200
/* Read from the process */
955
ret = read(proc->fd, proc->buffer + proc->buffer_length,
956
BUFFER_SIZE);
957
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){
958
1206
/* Read error from this process; ignore the error */
1207
proc = proc->next;
959
1208
continue;
960
1209
}
961
if(ret == 0){
1210
if(sret == 0){
962
1211
/* got EOF */
963
1212
proc->eof = true;
964
1213
} else {
965
proc->buffer_length += (size_t) ret;
1214
proc->buffer_length += (size_t) sret;
966
1215
}
967
1216
}
968
1217
}
969
970
1218
1219
971
1220
fallback:
972
1221
973
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1222
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1223
and exitstatus != EX_OK)){
974
1224
/* Fallback if all plugins failed, none are found or an error
975
1225
occured */
976
1226
bool bret;
977
1227
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
978
1228
char *passwordbuffer = getpass("Password: ");
979
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);
980
1236
if(not bret){
981
perror("print_out_password");
982
exitstatus = EXIT_FAILURE;
1237
error(0, errno, "print_out_password");
1238
exitstatus = EX_IOERR;
983
1239
}
984
1240
}
985
1241
986
1242
/* Restore old signal handler */
987
1243
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
988
1244
if(ret == -1){
989
perror("sigaction");
990
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "sigaction");
1246
exitstatus = EX_OSERR;
991
1247
}
992
1248
993
1249
if(custom_argv != NULL){
994
1250
for(char **arg = custom_argv+1; *arg != NULL; arg++){
995
1251
free(*arg);
1001
1257
closedir(dir);
1002
1258
}
1003
1259
1004
/* Free the process list and kill the processes */
1260
/* Kill the processes */
1005
1261
for(plugin *p = plugin_list; p != NULL; p = p->next){
1006
1262
if(p->pid != 0){
1007
1263
close(p->fd);
1008
1264
ret = kill(p->pid, SIGTERM);
1009
1265
if(ret == -1 and errno != ESRCH){
1010
1266
/* Set-uid proccesses might not get closed */
1011
perror("kill");
1267
error(0, errno, "kill");
1012
1268
}
1013
1269
}
1014
1270
}
1015
1271
1016
1272
/* Wait for any remaining child processes to terminate */
1017
do{
1273
do {
1018
1274
ret = wait(NULL);
1019
1275
} while(ret >= 0);
1020
1276
if(errno != ECHILD){
1021
perror("wait");
1277
error(0, errno, "wait");
1022
1278
}
1023
1279
1024
1280
free_plugin_list();
1025
1281
1026
1282
free(plugindir);
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0