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