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