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 749.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 749.1.1
- Committer: Teddy Hogeborn
- Date: 2015-05-23 20:18:34 UTC
- mto: This revision was merged to the branch mainline in revision 756.
- Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
- 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))){
123
128
copy_name = strdup(name);
124
129
} while(copy_name == NULL and errno == EINTR);
125
130
if(copy_name == NULL){
131
int e = errno;
126
132
free(new_plugin);
133
errno = e;
127
134
return NULL;
128
135
}
129
136
}
137
144
new_plugin->argv = malloc(sizeof(char *) * 2);
138
145
} while(new_plugin->argv == NULL and errno == EINTR);
139
146
if(new_plugin->argv == NULL){
147
int e = errno;
140
148
free(copy_name);
141
149
free(new_plugin);
150
errno = e;
142
151
return NULL;
143
152
}
144
153
new_plugin->argv[0] = copy_name;
148
157
new_plugin->environ = malloc(sizeof(char *));
149
158
} while(new_plugin->environ == NULL and errno == EINTR);
150
159
if(new_plugin->environ == NULL){
160
int e = errno;
151
161
free(copy_name);
152
162
free(new_plugin->argv);
153
163
free(new_plugin);
164
errno = e;
154
165
return NULL;
155
166
}
156
167
new_plugin->environ[0] = NULL;
161
172
}
162
173
163
174
/* Helper function for add_argument and add_environment */
175
__attribute__((nonnull, warn_unused_result))
164
176
static bool add_to_char_array(const char *new, char ***array,
165
177
int *len){
166
178
/* Resize the pointed-to array to hold one more pointer */
179
char **new_array = NULL;
167
180
do {
168
*array = realloc(*array, sizeof(char *)
169
* (size_t) ((*len) + 2));
170
} while(*array == NULL and errno == EINTR);
181
new_array = realloc(*array, sizeof(char *)
182
* (size_t) ((*len) + 2));
183
} while(new_array == NULL and errno == EINTR);
171
184
/* Malloc check */
172
if(*array == NULL){
185
if(new_array == NULL){
173
186
return false;
174
187
}
188
*array = new_array;
175
189
/* Make a copy of the new string */
176
190
char *copy;
177
191
do {
189
203
}
190
204
191
205
/* Add to a plugin's argument vector */
206
__attribute__((nonnull(2), warn_unused_result))
192
207
static bool add_argument(plugin *p, const char *arg){
193
208
if(p == NULL){
194
209
return false;
197
212
}
198
213
199
214
/* Add to a plugin's environment */
215
__attribute__((nonnull(2), warn_unused_result))
200
216
static bool add_environment(plugin *p, const char *def, bool replace){
201
217
if(p == NULL){
202
218
return false;
204
220
/* namelen = length of name of environment variable */
205
221
size_t namelen = (size_t)(strchrnul(def, '=') - def);
206
222
/* Search for this environment variable */
207
for(char **e = p->environ; *e != NULL; e++){
208
if(strncmp(*e, def, namelen + 1) == 0){
223
for(char **envdef = p->environ; *envdef != NULL; envdef++){
224
if(strncmp(*envdef, def, namelen + 1) == 0){
209
225
/* It already exists */
210
226
if(replace){
211
char *new;
227
char *new_envdef;
212
228
do {
213
new = realloc(*e, strlen(def) + 1);
214
} while(new == NULL and errno == EINTR);
215
if(new == NULL){
229
new_envdef = realloc(*envdef, strlen(def) + 1);
230
} while(new_envdef == NULL and errno == EINTR);
231
if(new_envdef == NULL){
216
232
return false;
217
233
}
218
*e = new;
219
strcpy(*e, def);
234
*envdef = new_envdef;
235
strcpy(*envdef, def);
220
236
}
221
237
return true;
222
238
}
224
240
return add_to_char_array(def, &(p->environ), &(p->envc));
225
241
}
226
242
243
#ifndef O_CLOEXEC
227
244
/*
228
245
* Based on the example in the GNU LibC manual chapter 13.13 "File
229
246
* Descriptor Flags".
230
247
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
231
248
*/
249
__attribute__((warn_unused_result))
232
250
static int set_cloexec_flag(int fd){
233
int ret = TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
251
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
234
252
/* If reading the flags failed, return error indication now. */
235
253
if(ret < 0){
236
254
return ret;
237
255
}
238
256
/* Store modified flag word in the descriptor. */
239
return TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD, ret | FD_CLOEXEC));
257
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
258
ret | FD_CLOEXEC));
240
259
}
260
#endif /* not O_CLOEXEC */
241
261
242
262
243
263
/* Mark processes as completed when they exit, and save their exit
257
277
/* No child processes */
258
278
break;
259
279
}
260
perror("waitpid");
280
error(0, errno, "waitpid");
261
281
}
262
282
263
283
/* A child exited, find it in process_list */
275
295
}
276
296
277
297
/* Prints out a password to stdout */
298
__attribute__((nonnull, warn_unused_result))
278
299
static bool print_out_password(const char *buffer, size_t length){
279
300
ssize_t ret;
280
301
for(size_t written = 0; written < length; written += (size_t)ret){
288
309
}
289
310
290
311
/* Removes and free a plugin from the plugin list */
312
__attribute__((nonnull))
291
313
static void free_plugin(plugin *plugin_node){
292
314
293
315
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
327
349
char *plugindir = NULL;
328
350
char *argfile = NULL;
329
351
FILE *conffp;
330
size_t d_name_len;
331
DIR *dir = NULL;
332
struct dirent *dirst;
352
struct dirent **direntries = NULL;
333
353
struct stat st;
334
354
fd_set rfds_all;
335
355
int ret, maxfd = 0;
343
363
.sa_flags = SA_NOCLDSTOP };
344
364
char **custom_argv = NULL;
345
365
int custom_argc = 0;
366
int dir_fd = -1;
346
367
347
368
/* Establish a signal handler */
348
369
sigemptyset(&sigchld_action.sa_mask);
349
370
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
350
371
if(ret == -1){
351
perror("sigaddset");
352
exitstatus = EXIT_FAILURE;
372
error(0, errno, "sigaddset");
373
exitstatus = EX_OSERR;
353
374
goto fallback;
354
375
}
355
376
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
356
377
if(ret == -1){
357
perror("sigaction");
358
exitstatus = EXIT_FAILURE;
378
error(0, errno, "sigaction");
379
exitstatus = EX_OSERR;
359
380
goto fallback;
360
381
}
361
382
393
414
.doc = "Group ID the plugins will run as", .group = 3 },
394
415
{ .name = "debug", .key = 132,
395
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 },
396
426
{ .name = NULL }
397
427
};
398
428
399
error_t parse_opt(int key, char *arg, __attribute__((unused))
400
struct argp_state *state){
429
__attribute__((nonnull(3)))
430
error_t parse_opt(int key, char *arg, struct argp_state *state){
431
errno = 0;
401
432
switch(key){
402
433
char *tmp;
403
intmax_t tmpmax;
434
intmax_t tmp_id;
404
435
case 'g': /* --global-options */
405
if(arg != NULL){
436
{
406
437
char *plugin_option;
407
438
while((plugin_option = strsep(&arg, ",")) != NULL){
408
if(plugin_option[0] == '\0'){
409
continue;
410
}
411
439
if(not add_argument(getplugin(NULL), plugin_option)){
412
perror("add_argument");
413
return ARGP_ERR_UNKNOWN;
440
break;
414
441
}
415
442
}
443
errno = 0;
416
444
}
417
445
break;
418
446
case 'G': /* --global-env */
419
if(arg == NULL){
420
break;
421
}
422
if(not add_environment(getplugin(NULL), arg, true)){
423
perror("add_environment");
447
if(add_environment(getplugin(NULL), arg, true)){
448
errno = 0;
424
449
}
425
450
break;
426
451
case 'o': /* --options-for */
427
if(arg != NULL){
428
char *plugin_name = strsep(&arg, ":");
429
if(plugin_name[0] == '\0'){
430
break;
431
}
432
char *plugin_option;
433
while((plugin_option = strsep(&arg, ",")) != NULL){
434
if(not add_argument(getplugin(plugin_name), plugin_option)){
435
perror("add_argument");
436
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;
437
470
}
438
471
}
472
errno = 0;
439
473
}
440
474
break;
441
475
case 'E': /* --env-for */
442
if(arg == NULL){
443
break;
444
}
445
476
{
446
477
char *envdef = strchr(arg, ':');
447
478
if(envdef == NULL){
479
argp_error(state, "No colon in \"%s\"", arg);
480
errno = EINVAL;
448
481
break;
449
482
}
450
483
*envdef = '\0';
451
if(not add_environment(getplugin(arg), envdef+1, true)){
452
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;
453
492
}
454
493
}
455
494
break;
456
495
case 'd': /* --disable */
457
if(arg != NULL){
496
{
458
497
plugin *p = getplugin(arg);
459
if(p == NULL){
460
return ARGP_ERR_UNKNOWN;
498
if(p != NULL){
499
p->disabled = true;
500
errno = 0;
461
501
}
462
p->disabled = true;
463
502
}
464
503
break;
465
504
case 'e': /* --enable */
466
if(arg != NULL){
505
{
467
506
plugin *p = getplugin(arg);
468
if(p == NULL){
469
return ARGP_ERR_UNKNOWN;
507
if(p != NULL){
508
p->disabled = false;
509
errno = 0;
470
510
}
471
p->disabled = false;
472
511
}
473
512
break;
474
513
case 128: /* --plugin-dir */
475
514
free(plugindir);
476
515
plugindir = strdup(arg);
477
if(plugindir == NULL){
478
perror("strdup");
516
if(plugindir != NULL){
517
errno = 0;
479
518
}
480
519
break;
481
520
case 129: /* --config-file */
482
521
/* This is already done by parse_opt_config_file() */
483
522
break;
484
523
case 130: /* --userid */
485
errno = 0;
486
tmpmax = strtoimax(arg, &tmp, 10);
524
tmp_id = strtoimax(arg, &tmp, 10);
487
525
if(errno != 0 or tmp == arg or *tmp != '\0'
488
or tmpmax != (uid_t)tmpmax){
489
fprintf(stderr, "Bad user ID number: \"%s\", using %"
490
PRIdMAX "\n", arg, (intmax_t)uid);
491
} else {
492
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;
493
530
}
531
uid = (uid_t)tmp_id;
532
errno = 0;
494
533
break;
495
534
case 131: /* --groupid */
496
errno = 0;
497
tmpmax = strtoimax(arg, &tmp, 10);
535
tmp_id = strtoimax(arg, &tmp, 10);
498
536
if(errno != 0 or tmp == arg or *tmp != '\0'
499
or tmpmax != (gid_t)tmpmax){
500
fprintf(stderr, "Bad group ID number: \"%s\", using %"
501
PRIdMAX "\n", arg, (intmax_t)gid);
502
} else {
503
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;
504
541
}
542
gid = (gid_t)tmp_id;
543
errno = 0;
505
544
break;
506
545
case 132: /* --debug */
507
546
debug = true;
508
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;
509
562
/*
510
563
* When adding more options before this line, remember to also add a
511
564
* "case" to the "parse_opt_config_file" function below.
514
567
/* Cryptsetup always passes an argument, which is an empty
515
568
string if "none" was specified in /etc/crypttab. So if
516
569
argument was empty, we ignore it silently. */
517
if(arg[0] != '\0'){
518
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
570
if(arg[0] == '\0'){
571
break;
519
572
}
520
break;
521
case ARGP_KEY_END:
522
break;
523
573
default:
524
574
return ARGP_ERR_UNKNOWN;
525
575
}
526
return 0;
576
return errno; /* Set to 0 at start */
527
577
}
528
578
529
579
/* This option parser is the same as parse_opt() above, except it
531
581
error_t parse_opt_config_file(int key, char *arg,
532
582
__attribute__((unused))
533
583
struct argp_state *state){
584
errno = 0;
534
585
switch(key){
535
586
case 'g': /* --global-options */
536
587
case 'G': /* --global-env */
543
594
case 129: /* --config-file */
544
595
free(argfile);
545
596
argfile = strdup(arg);
546
if(argfile == NULL){
547
perror("strdup");
597
if(argfile != NULL){
598
errno = 0;
548
599
}
549
600
break;
550
601
case 130: /* --userid */
551
602
case 131: /* --groupid */
552
603
case 132: /* --debug */
604
case '?': /* --help */
605
case -3: /* --usage */
606
case 'V': /* --version */
553
607
case ARGP_KEY_ARG:
554
case ARGP_KEY_END:
555
608
break;
556
609
default:
557
610
return ARGP_ERR_UNKNOWN;
558
611
}
559
return 0;
612
return errno;
560
613
}
561
614
562
615
struct argp argp = { .options = options,
566
619
567
620
/* Parse using parse_opt_config_file() in order to get the custom
568
621
config file location, if any. */
569
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
570
if(ret == ARGP_ERR_UNKNOWN){
571
fprintf(stderr, "Unknown error while parsing arguments\n");
572
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;
573
636
goto fallback;
574
637
}
575
638
592
655
custom_argc = 1;
593
656
custom_argv = malloc(sizeof(char*) * 2);
594
657
if(custom_argv == NULL){
595
perror("malloc");
596
exitstatus = EXIT_FAILURE;
658
error(0, errno, "malloc");
659
exitstatus = EX_OSERR;
597
660
goto fallback;
598
661
}
599
662
custom_argv[0] = argv[0];
615
678
}
616
679
new_arg = strdup(p);
617
680
if(new_arg == NULL){
618
perror("strdup");
619
exitstatus = EXIT_FAILURE;
681
error(0, errno, "strdup");
682
exitstatus = EX_OSERR;
620
683
free(org_line);
621
684
goto fallback;
622
685
}
623
686
624
687
custom_argc += 1;
625
custom_argv = realloc(custom_argv, sizeof(char *)
626
* ((unsigned int) custom_argc + 1));
627
if(custom_argv == NULL){
628
perror("realloc");
629
exitstatus = EXIT_FAILURE;
630
free(org_line);
631
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
}
632
701
}
633
702
custom_argv[custom_argc-1] = new_arg;
634
703
custom_argv[custom_argc] = NULL;
638
707
ret = fclose(conffp);
639
708
} while(ret == EOF and errno == EINTR);
640
709
if(ret == EOF){
641
perror("fclose");
642
exitstatus = EXIT_FAILURE;
710
error(0, errno, "fclose");
711
exitstatus = EX_IOERR;
643
712
goto fallback;
644
713
}
645
714
free(org_line);
647
716
/* Check for harmful errors and go to fallback. Other errors might
648
717
not affect opening plugins */
649
718
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
650
perror("fopen");
651
exitstatus = EXIT_FAILURE;
719
error(0, errno, "fopen");
720
exitstatus = EX_OSERR;
652
721
goto fallback;
653
722
}
654
723
}
655
/* If there was any arguments from configuration file,
656
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 */
657
726
if(custom_argv != NULL){
658
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
659
0, NULL);
660
if(ret == ARGP_ERR_UNKNOWN){
661
fprintf(stderr, "Unknown error while parsing arguments\n");
662
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;
663
741
goto fallback;
664
742
}
665
743
}
666
744
667
745
/* Parse actual command line arguments, to let them override the
668
746
config file */
669
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
670
if(ret == ARGP_ERR_UNKNOWN){
671
fprintf(stderr, "Unknown error while parsing arguments\n");
672
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;
673
761
goto fallback;
674
762
}
675
763
687
775
}
688
776
}
689
777
690
/* Strip permissions down to nobody */
691
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);
692
804
if(ret == -1){
693
perror("setgid");
805
error(0, errno, "setgid");
694
806
}
695
807
ret = setuid(uid);
696
808
if(ret == -1){
697
perror("setuid");
698
}
699
700
if(plugindir == NULL){
701
dir = opendir(PDIR);
702
} else {
703
dir = opendir(plugindir);
704
}
705
706
if(dir == NULL){
707
perror("Could not open plugin dir");
708
exitstatus = EXIT_FAILURE;
709
goto fallback;
710
}
711
712
/* 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 */
713
813
{
714
int dir_fd = dirfd(dir);
715
if(dir_fd >= 0){
716
ret = set_cloexec_flag(dir_fd);
717
if(ret < 0){
718
perror("set_cloexec_flag");
719
exitstatus = EXIT_FAILURE;
720
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;
721
858
}
722
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;
723
880
}
724
881
725
882
FD_ZERO(&rfds_all);
726
883
727
884
/* Read and execute any executable in the plugin directory*/
728
while(true){
729
do {
730
dirst = readdir(dir);
731
} while(dirst == NULL and errno == EINTR);
732
733
/* All directory entries have been processed */
734
if(dirst == NULL){
735
if(errno == EBADF){
736
perror("readdir");
737
exitstatus = EXIT_FAILURE;
738
goto fallback;
739
}
740
break;
741
}
742
743
d_name_len = strlen(dirst->d_name);
744
745
/* Ignore dotfiles, backup files and other junk */
746
{
747
bool bad_name = false;
748
749
const char const *bad_prefixes[] = { ".", "#", NULL };
750
751
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
752
".dpkg-old",
753
".dpkg-bak",
754
".dpkg-divert", NULL };
755
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
756
size_t pre_len = strlen(*pre);
757
if((d_name_len >= pre_len)
758
and strncmp((dirst->d_name), *pre, pre_len) == 0){
759
if(debug){
760
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
761
" with bad prefix %s\n", dirst->d_name, *pre);
762
}
763
bad_name = true;
764
break;
765
}
766
}
767
if(bad_name){
768
continue;
769
}
770
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
771
size_t suf_len = strlen(*suf);
772
if((d_name_len >= suf_len)
773
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
774
== 0)){
775
if(debug){
776
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
777
" with bad suffix %s\n", dirst->d_name, *suf);
778
}
779
bad_name = true;
780
break;
781
}
782
}
783
784
if(bad_name){
785
continue;
786
}
787
}
788
789
char *filename;
790
if(plugindir == NULL){
791
ret = TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
792
dirst->d_name));
793
} else {
794
ret = TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s", plugindir,
795
dirst->d_name));
796
}
797
if(ret < 0){
798
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]);
799
891
continue;
800
892
}
801
802
ret = TEMP_FAILURE_RETRY(stat(filename, &st));
893
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
803
894
if(ret == -1){
804
perror("stat");
805
free(filename);
895
error(0, errno, "stat");
896
TEMP_FAILURE_RETRY(close(plugin_fd));
897
free(direntries[i]);
806
898
continue;
807
899
}
808
900
809
901
/* Ignore non-executable files */
810
902
if(not S_ISREG(st.st_mode)
811
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
903
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
904
X_OK, 0)) != 0)){
812
905
if(debug){
813
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
814
" 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);
815
910
}
816
free(filename);
911
TEMP_FAILURE_RETRY(close(plugin_fd));
912
free(direntries[i]);
817
913
continue;
818
914
}
819
915
820
plugin *p = getplugin(dirst->d_name);
916
plugin *p = getplugin(direntries[i]->d_name);
821
917
if(p == NULL){
822
perror("getplugin");
823
free(filename);
918
error(0, errno, "getplugin");
919
TEMP_FAILURE_RETRY(close(plugin_fd));
920
free(direntries[i]);
824
921
continue;
825
922
}
826
923
if(p->disabled){
827
924
if(debug){
828
925
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
829
dirst->d_name);
926
direntries[i]->d_name);
830
927
}
831
free(filename);
928
TEMP_FAILURE_RETRY(close(plugin_fd));
929
free(direntries[i]);
832
930
continue;
833
931
}
834
932
{
837
935
if(g != NULL){
838
936
for(char **a = g->argv + 1; *a != NULL; a++){
839
937
if(not add_argument(p, *a)){
840
perror("add_argument");
938
error(0, errno, "add_argument");
841
939
}
842
940
}
843
941
/* Add global environment variables */
844
942
for(char **e = g->environ; *e != NULL; e++){
845
943
if(not add_environment(p, *e, false)){
846
perror("add_environment");
944
error(0, errno, "add_environment");
847
945
}
848
946
}
849
947
}
850
948
}
851
/* If this plugin has any environment variables, we will call
852
using execve and need to duplicate the environment from this
853
process, too. */
949
/* If this plugin has any environment variables, we need to
950
duplicate the environment from this process, too. */
854
951
if(p->environ[0] != NULL){
855
952
for(char **e = environ; *e != NULL; e++){
856
953
if(not add_environment(p, *e, false)){
857
perror("add_environment");
954
error(0, errno, "add_environment");
858
955
}
859
956
}
860
957
}
861
958
862
959
int pipefd[2];
863
ret = TEMP_FAILURE_RETRY(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 */
864
965
if(ret == -1){
865
perror("pipe");
866
exitstatus = EXIT_FAILURE;
867
goto fallback;
868
}
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
869
981
/* Ask OS to automatic close the pipe on exec */
870
982
ret = set_cloexec_flag(pipefd[0]);
871
983
if(ret < 0){
872
perror("set_cloexec_flag");
873
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]);
874
989
goto fallback;
875
990
}
876
991
ret = set_cloexec_flag(pipefd[1]);
877
992
if(ret < 0){
878
perror("set_cloexec_flag");
879
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]);
880
998
goto fallback;
881
999
}
1000
#endif /* not O_CLOEXEC */
882
1001
/* Block SIGCHLD until process is safely in process list */
883
ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
884
&sigchld_action.sa_mask,
885
NULL));
1002
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1003
&sigchld_action.sa_mask,
1004
NULL));
886
1005
if(ret < 0){
887
perror("sigprocmask");
888
exitstatus = EXIT_FAILURE;
1006
error(0, errno, "sigprocmask");
1007
exitstatus = EX_OSERR;
1008
free(direntries[i]);
889
1009
goto fallback;
890
1010
}
891
1011
/* Starting a new process to be watched */
894
1014
pid = fork();
895
1015
} while(pid == -1 and errno == EINTR);
896
1016
if(pid == -1){
897
perror("fork");
898
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]);
899
1024
goto fallback;
900
1025
}
901
1026
if(pid == 0){
902
1027
/* this is the child process */
903
1028
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
904
1029
if(ret < 0){
905
perror("sigaction");
906
_exit(EXIT_FAILURE);
1030
error(0, errno, "sigaction");
1031
_exit(EX_OSERR);
907
1032
}
908
1033
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
909
1034
if(ret < 0){
910
perror("sigprocmask");
911
_exit(EXIT_FAILURE);
1035
error(0, errno, "sigprocmask");
1036
_exit(EX_OSERR);
912
1037
}
913
1038
914
1039
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
915
1040
if(ret == -1){
916
perror("dup2");
917
_exit(EXIT_FAILURE);
1041
error(0, errno, "dup2");
1042
_exit(EX_OSERR);
918
1043
}
919
1044
920
if(dirfd(dir) < 0){
921
/* If dir has no file descriptor, we could not set FD_CLOEXEC
922
above and must now close it manually here. */
923
closedir(dir);
924
}
925
if(p->environ[0] == NULL){
926
if(execv(filename, p->argv) < 0){
927
perror("execv");
928
_exit(EXIT_FAILURE);
929
}
930
} else {
931
if(execve(filename, p->argv, p->environ) < 0){
932
perror("execve");
933
_exit(EXIT_FAILURE);
934
}
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);
935
1051
}
936
1052
/* no return */
937
1053
}
938
1054
/* Parent process */
939
1055
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
940
1056
pipe */
941
free(filename);
942
plugin *new_plugin = getplugin(dirst->d_name);
1057
TEMP_FAILURE_RETRY(close(plugin_fd));
1058
plugin *new_plugin = getplugin(direntries[i]->d_name);
943
1059
if(new_plugin == NULL){
944
perror("getplugin");
945
ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
946
&sigchld_action.sa_mask,
947
NULL));
1060
error(0, errno, "getplugin");
1061
ret = (int)(TEMP_FAILURE_RETRY
1062
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1063
NULL)));
948
1064
if(ret < 0){
949
perror("sigprocmask");
1065
error(0, errno, "sigprocmask");
950
1066
}
951
exitstatus = EXIT_FAILURE;
1067
exitstatus = EX_OSERR;
1068
free(direntries[i]);
952
1069
goto fallback;
953
1070
}
1071
free(direntries[i]);
954
1072
955
1073
new_plugin->pid = pid;
956
1074
new_plugin->fd = pipefd[0];
957
1075
958
1076
/* Unblock SIGCHLD so signal handler can be run if this process
959
1077
has already completed */
960
ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
961
&sigchld_action.sa_mask,
962
NULL));
1078
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1079
&sigchld_action.sa_mask,
1080
NULL));
963
1081
if(ret < 0){
964
perror("sigprocmask");
965
exitstatus = EXIT_FAILURE;
1082
error(0, errno, "sigprocmask");
1083
exitstatus = EX_OSERR;
966
1084
goto fallback;
967
1085
}
968
1086
969
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
970
1101
971
1102
if(maxfd < new_plugin->fd){
972
1103
maxfd = new_plugin->fd;
973
1104
}
974
1105
}
975
1106
976
TEMP_FAILURE_RETRY(closedir(dir));
977
dir = NULL;
1107
free(direntries);
1108
direntries = NULL;
1109
TEMP_FAILURE_RETRY(close(dir_fd));
1110
dir_fd = -1;
978
1111
free_plugin(getplugin(NULL));
979
1112
980
1113
for(plugin *p = plugin_list; p != NULL; p = p->next){
993
1126
fd_set rfds = rfds_all;
994
1127
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
995
1128
if(select_ret == -1 and errno != EINTR){
996
perror("select");
997
exitstatus = EXIT_FAILURE;
1129
error(0, errno, "select");
1130
exitstatus = EX_OSERR;
998
1131
goto fallback;
999
1132
}
1000
1133
/* OK, now either a process completed, or something can be read
1026
1159
}
1027
1160
1028
1161
/* Remove the plugin */
1029
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
1030
1176
1031
1177
/* Block signal while modifying process_list */
1032
ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1033
&sigchld_action.sa_mask,
1034
NULL));
1178
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1179
(SIG_BLOCK,
1180
&sigchld_action.sa_mask,
1181
NULL));
1035
1182
if(ret < 0){
1036
perror("sigprocmask");
1037
exitstatus = EXIT_FAILURE;
1183
error(0, errno, "sigprocmask");
1184
exitstatus = EX_OSERR;
1038
1185
goto fallback;
1039
1186
}
1040
1187
1043
1190
proc = next_plugin;
1044
1191
1045
1192
/* We are done modifying process list, so unblock signal */
1046
ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1047
&sigchld_action.sa_mask,
1048
NULL));
1193
ret = (int)(TEMP_FAILURE_RETRY
1194
(sigprocmask(SIG_UNBLOCK,
1195
&sigchld_action.sa_mask, NULL)));
1049
1196
if(ret < 0){
1050
perror("sigprocmask");
1051
exitstatus = EXIT_FAILURE;
1197
error(0, errno, "sigprocmask");
1198
exitstatus = EX_OSERR;
1052
1199
goto fallback;
1053
1200
}
1054
1201
1064
1211
bool bret = print_out_password(proc->buffer,
1065
1212
proc->buffer_length);
1066
1213
if(not bret){
1067
perror("print_out_password");
1068
exitstatus = EXIT_FAILURE;
1214
error(0, errno, "print_out_password");
1215
exitstatus = EX_IOERR;
1069
1216
}
1070
1217
goto fallback;
1071
1218
}
1072
1219
1073
1220
/* This process has not completed. Does it have any output? */
1074
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
1075
1238
/* This process had nothing to say at this time */
1076
1239
proc = proc->next;
1077
1240
continue;
1078
1241
}
1079
1242
/* Before reading, make the process' data buffer large enough */
1080
1243
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1081
proc->buffer = realloc(proc->buffer, proc->buffer_size
1082
+ (size_t) BUFFER_SIZE);
1083
if(proc->buffer == NULL){
1084
perror("malloc");
1085
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;
1086
1249
goto fallback;
1087
1250
}
1251
proc->buffer = new_buffer;
1088
1252
proc->buffer_size += BUFFER_SIZE;
1089
1253
}
1090
1254
/* Read from the process */
1109
1273
1110
1274
fallback:
1111
1275
1112
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1276
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1277
and exitstatus != EX_OK)){
1113
1278
/* Fallback if all plugins failed, none are found or an error
1114
1279
occured */
1115
1280
bool bret;
1123
1288
}
1124
1289
bret = print_out_password(passwordbuffer, len);
1125
1290
if(not bret){
1126
perror("print_out_password");
1127
exitstatus = EXIT_FAILURE;
1291
error(0, errno, "print_out_password");
1292
exitstatus = EX_IOERR;
1128
1293
}
1129
1294
}
1130
1295
1131
1296
/* Restore old signal handler */
1132
1297
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1133
1298
if(ret == -1){
1134
perror("sigaction");
1135
exitstatus = EXIT_FAILURE;
1299
error(0, errno, "sigaction");
1300
exitstatus = EX_OSERR;
1136
1301
}
1137
1302
1138
1303
if(custom_argv != NULL){
1142
1307
free(custom_argv);
1143
1308
}
1144
1309
1145
if(dir != NULL){
1146
closedir(dir);
1310
free(direntries);
1311
1312
if(dir_fd != -1){
1313
TEMP_FAILURE_RETRY(close(dir_fd));
1147
1314
}
1148
1315
1149
1316
/* Kill the processes */
1153
1320
ret = kill(p->pid, SIGTERM);
1154
1321
if(ret == -1 and errno != ESRCH){
1155
1322
/* Set-uid proccesses might not get closed */
1156
perror("kill");
1323
error(0, errno, "kill");
1157
1324
}
1158
1325
}
1159
1326
}
1163
1330
ret = wait(NULL);
1164
1331
} while(ret >= 0);
1165
1332
if(errno != ECHILD){
1166
perror("wait");
1333
error(0, errno, "wait");
1167
1334
}
1168
1335
1169
1336
free_plugin_list();
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0