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