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