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