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