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