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 1229
- compare with another revision
- download diff
- download tarball
- view history from revision 1229
- Committer: teddy at recompile
- Date: 2020-12-03 20:30:45 UTC
- Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
- files added:
- DBUS-API
- debian/source
- debian/tests
- debian/upstream
- dracut-module
- 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-2020 Teddy Hogeborn
6
* Copyright © 2008-2020 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(), reallocarray(), realloc(),
30
EXIT_SUCCESS, exit() */
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
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
183
new_array = reallocarray(*array, (size_t)((*len) + 2),
184
sizeof(char *));
185
#else
186
if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
187
/* overflow */
188
new_array = NULL;
189
errno = ENOMEM;
190
} else {
191
new_array = realloc(*array, (size_t)((*len) + 2)
192
* sizeof(char *));
193
}
194
#endif
195
} while(new_array == NULL and errno == EINTR);
157
196
/* Malloc check */
158
if(*array == NULL){
197
if(new_array == NULL){
159
198
return false;
160
199
}
200
*array = new_array;
161
201
/* Make a copy of the new string */
162
char *copy = strdup(new);
202
char *copy;
203
do {
204
copy = strdup(new);
205
} while(copy == NULL and errno == EINTR);
163
206
if(copy == NULL){
164
207
return false;
165
208
}
172
215
}
173
216
174
217
/* Add to a plugin's argument vector */
218
__attribute__((nonnull(2), warn_unused_result))
175
219
static bool add_argument(plugin *p, const char *arg){
176
220
if(p == NULL){
177
221
return false;
180
224
}
181
225
182
226
/* Add to a plugin's environment */
227
__attribute__((nonnull(2), warn_unused_result))
183
228
static bool add_environment(plugin *p, const char *def, bool replace){
184
229
if(p == NULL){
185
230
return false;
187
232
/* namelen = length of name of environment variable */
188
233
size_t namelen = (size_t)(strchrnul(def, '=') - def);
189
234
/* Search for this environment variable */
190
for(char **e = p->environ; *e != NULL; e++){
191
if(strncmp(*e, def, namelen + 1) == 0){
235
for(char **envdef = p->environ; *envdef != NULL; envdef++){
236
if(strncmp(*envdef, def, namelen + 1) == 0){
192
237
/* It already exists */
193
238
if(replace){
194
char *new = realloc(*e, strlen(def) + 1);
195
if(new == NULL){
239
char *new_envdef;
240
do {
241
new_envdef = realloc(*envdef, strlen(def) + 1);
242
} while(new_envdef == NULL and errno == EINTR);
243
if(new_envdef == NULL){
196
244
return false;
197
245
}
198
*e = new;
199
strcpy(*e, def);
246
*envdef = new_envdef;
247
strcpy(*envdef, def);
200
248
}
201
249
return true;
202
250
}
204
252
return add_to_char_array(def, &(p->environ), &(p->envc));
205
253
}
206
254
255
#ifndef O_CLOEXEC
207
256
/*
208
257
* Based on the example in the GNU LibC manual chapter 13.13 "File
209
258
* Descriptor Flags".
210
* *Note File Descriptor Flags:(libc)Descriptor Flags.
259
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
211
260
*/
261
__attribute__((warn_unused_result))
212
262
static int set_cloexec_flag(int fd){
213
int ret = fcntl(fd, F_GETFD, 0);
263
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
214
264
/* If reading the flags failed, return error indication now. */
215
265
if(ret < 0){
216
266
return ret;
217
267
}
218
268
/* Store modified flag word in the descriptor. */
219
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
269
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
270
ret | FD_CLOEXEC));
220
271
}
272
#endif /* not O_CLOEXEC */
221
273
222
274
223
275
/* Mark processes as completed when they exit, and save their exit
237
289
/* No child processes */
238
290
break;
239
291
}
240
perror("waitpid");
292
error(0, errno, "waitpid");
241
293
}
242
294
243
295
/* A child exited, find it in process_list */
255
307
}
256
308
257
309
/* Prints out a password to stdout */
310
__attribute__((nonnull, warn_unused_result))
258
311
static bool print_out_password(const char *buffer, size_t length){
259
312
ssize_t ret;
260
313
for(size_t written = 0; written < length; written += (size_t)ret){
268
321
}
269
322
270
323
/* Removes and free a plugin from the plugin list */
324
__attribute__((nonnull))
271
325
static void free_plugin(plugin *plugin_node){
272
326
273
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
327
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
274
328
free(*arg);
275
329
}
330
free(plugin_node->name);
276
331
free(plugin_node->argv);
277
332
for(char **env = plugin_node->environ; *env != NULL; env++){
278
333
free(*env);
279
334
}
280
335
free(plugin_node->environ);
281
336
free(plugin_node->buffer);
282
337
283
338
/* Removes the plugin from the singly-linked list */
284
339
if(plugin_node == plugin_list){
285
340
/* First one - simple */
305
360
306
361
int main(int argc, char *argv[]){
307
362
char *plugindir = NULL;
363
char *pluginhelperdir = NULL;
308
364
char *argfile = NULL;
309
365
FILE *conffp;
310
size_t d_name_len;
311
DIR *dir = NULL;
312
struct dirent *dirst;
366
struct dirent **direntries = NULL;
313
367
struct stat st;
314
368
fd_set rfds_all;
315
int ret, numchars, maxfd = 0;
369
int ret, maxfd = 0;
316
370
ssize_t sret;
317
intmax_t tmpmax;
318
371
uid_t uid = 65534;
319
372
gid_t gid = 65534;
320
373
bool debug = false;
324
377
.sa_flags = SA_NOCLDSTOP };
325
378
char **custom_argv = NULL;
326
379
int custom_argc = 0;
380
int dir_fd = -1;
327
381
328
382
/* Establish a signal handler */
329
383
sigemptyset(&sigchld_action.sa_mask);
330
384
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
331
385
if(ret == -1){
332
perror("sigaddset");
333
exitstatus = EXIT_FAILURE;
386
error(0, errno, "sigaddset");
387
exitstatus = EX_OSERR;
334
388
goto fallback;
335
389
}
336
390
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
337
391
if(ret == -1){
338
perror("sigaction");
339
exitstatus = EXIT_FAILURE;
392
error(0, errno, "sigaction");
393
exitstatus = EX_OSERR;
340
394
goto fallback;
341
395
}
342
396
374
428
.doc = "Group ID the plugins will run as", .group = 3 },
375
429
{ .name = "debug", .key = 132,
376
430
.doc = "Debug mode", .group = 4 },
431
{ .name = "plugin-helper-dir", .key = 133,
432
.arg = "DIRECTORY",
433
.doc = "Specify a different plugin helper directory",
434
.group = 2 },
435
/*
436
* These reproduce what we would get without ARGP_NO_HELP
437
*/
438
{ .name = "help", .key = '?',
439
.doc = "Give this help list", .group = -1 },
440
{ .name = "usage", .key = -3,
441
.doc = "Give a short usage message", .group = -1 },
442
{ .name = "version", .key = 'V',
443
.doc = "Print program version", .group = -1 },
377
444
{ .name = NULL }
378
445
};
379
446
380
error_t parse_opt(int key, char *arg, __attribute__((unused))
381
struct argp_state *state){
447
__attribute__((nonnull(3)))
448
error_t parse_opt(int key, char *arg, struct argp_state *state){
449
errno = 0;
382
450
switch(key){
451
char *tmp;
452
intmax_t tmp_id;
383
453
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;
454
{
455
char *plugin_option;
456
while((plugin_option = strsep(&arg, ",")) != NULL){
457
if(not add_argument(getplugin(NULL), plugin_option)){
458
break;
393
459
}
394
460
}
461
errno = 0;
395
462
}
396
463
break;
397
464
case 'G': /* --global-env */
398
if(arg == NULL){
399
break;
400
}
401
if(not add_environment(getplugin(NULL), arg, true)){
402
perror("add_environment");
465
if(add_environment(getplugin(NULL), arg, true)){
466
errno = 0;
403
467
}
404
468
break;
405
469
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
}
470
{
471
char *option_list = strchr(arg, ':');
472
if(option_list == NULL){
473
argp_error(state, "No colon in \"%s\"", arg);
474
errno = EINVAL;
475
break;
476
}
477
*option_list = '\0';
478
option_list++;
479
if(arg[0] == '\0'){
480
argp_error(state, "Empty plugin name");
481
errno = EINVAL;
482
break;
483
}
484
char *option;
485
while((option = strsep(&option_list, ",")) != NULL){
486
if(not add_argument(getplugin(arg), option)){
487
break;
488
}
489
}
490
errno = 0;
425
491
}
426
492
break;
427
493
case 'E': /* --env-for */
428
if(arg == NULL){
429
break;
430
}
431
494
{
432
495
char *envdef = strchr(arg, ':');
433
496
if(envdef == NULL){
497
argp_error(state, "No colon in \"%s\"", arg);
498
errno = EINVAL;
434
499
break;
435
500
}
436
501
*envdef = '\0';
437
if(not add_environment(getplugin(arg), envdef+1, true)){
438
perror("add_environment");
502
envdef++;
503
if(arg[0] == '\0'){
504
argp_error(state, "Empty plugin name");
505
errno = EINVAL;
506
break;
507
}
508
if(add_environment(getplugin(arg), envdef, true)){
509
errno = 0;
439
510
}
440
511
}
441
512
break;
442
513
case 'd': /* --disable */
443
if(arg != NULL){
514
{
444
515
plugin *p = getplugin(arg);
445
if(p == NULL){
446
return ARGP_ERR_UNKNOWN;
516
if(p != NULL){
517
p->disabled = true;
518
errno = 0;
447
519
}
448
p->disabled = true;
449
520
}
450
521
break;
451
522
case 'e': /* --enable */
452
if(arg != NULL){
523
{
453
524
plugin *p = getplugin(arg);
454
if(p == NULL){
455
return ARGP_ERR_UNKNOWN;
525
if(p != NULL){
526
p->disabled = false;
527
errno = 0;
456
528
}
457
p->disabled = false;
458
529
}
459
530
break;
460
531
case 128: /* --plugin-dir */
461
532
free(plugindir);
462
533
plugindir = strdup(arg);
463
if(plugindir == NULL){
464
perror("strdup");
465
}
534
if(plugindir != NULL){
535
errno = 0;
536
}
466
537
break;
467
538
case 129: /* --config-file */
468
539
/* This is already done by parse_opt_config_file() */
469
540
break;
470
541
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;
542
tmp_id = strtoimax(arg, &tmp, 10);
543
if(errno != 0 or tmp == arg or *tmp != '\0'
544
or tmp_id != (uid_t)tmp_id){
545
argp_error(state, "Bad user ID number: \"%s\", using %"
546
PRIdMAX, arg, (intmax_t)uid);
547
break;
478
548
}
549
uid = (uid_t)tmp_id;
550
errno = 0;
479
551
break;
480
552
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;
553
tmp_id = strtoimax(arg, &tmp, 10);
554
if(errno != 0 or tmp == arg or *tmp != '\0'
555
or tmp_id != (gid_t)tmp_id){
556
argp_error(state, "Bad group ID number: \"%s\", using %"
557
PRIdMAX, arg, (intmax_t)gid);
558
break;
488
559
}
560
gid = (gid_t)tmp_id;
561
errno = 0;
489
562
break;
490
563
case 132: /* --debug */
491
564
debug = true;
492
565
break;
566
case 133: /* --plugin-helper-dir */
567
free(pluginhelperdir);
568
pluginhelperdir = strdup(arg);
569
if(pluginhelperdir != NULL){
570
errno = 0;
571
}
572
break;
573
/*
574
* These reproduce what we would get without ARGP_NO_HELP
575
*/
576
case '?': /* --help */
577
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
578
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
579
__builtin_unreachable();
580
case -3: /* --usage */
581
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
582
argp_state_help(state, state->out_stream,
583
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
584
__builtin_unreachable();
585
case 'V': /* --version */
586
fprintf(state->out_stream, "%s\n", argp_program_version);
587
exit(EXIT_SUCCESS);
588
break;
493
589
/*
494
590
* When adding more options before this line, remember to also add a
495
591
* "case" to the "parse_opt_config_file" function below.
498
594
/* Cryptsetup always passes an argument, which is an empty
499
595
string if "none" was specified in /etc/crypttab. So if
500
596
argument was empty, we ignore it silently. */
501
if(arg[0] != '\0'){
502
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
597
if(arg[0] == '\0'){
598
break;
503
599
}
504
break;
505
case ARGP_KEY_END:
506
break;
600
#if __GNUC__ >= 7
601
__attribute__((fallthrough));
602
#else
603
/* FALLTHROUGH */
604
#endif
507
605
default:
508
606
return ARGP_ERR_UNKNOWN;
509
607
}
510
return 0;
608
return errno; /* Set to 0 at start */
511
609
}
512
610
513
611
/* This option parser is the same as parse_opt() above, except it
515
613
error_t parse_opt_config_file(int key, char *arg,
516
614
__attribute__((unused))
517
615
struct argp_state *state){
616
errno = 0;
518
617
switch(key){
519
618
case 'g': /* --global-options */
520
619
case 'G': /* --global-env */
527
626
case 129: /* --config-file */
528
627
free(argfile);
529
628
argfile = strdup(arg);
530
if(argfile == NULL){
531
perror("strdup");
629
if(argfile != NULL){
630
errno = 0;
532
631
}
533
break;
632
break;
534
633
case 130: /* --userid */
535
634
case 131: /* --groupid */
536
635
case 132: /* --debug */
636
case 133: /* --plugin-helper-dir */
637
case '?': /* --help */
638
case -3: /* --usage */
639
case 'V': /* --version */
537
640
case ARGP_KEY_ARG:
538
case ARGP_KEY_END:
539
641
break;
540
642
default:
541
643
return ARGP_ERR_UNKNOWN;
542
644
}
543
return 0;
645
return errno;
544
646
}
545
647
546
648
struct argp argp = { .options = options,
550
652
551
653
/* Parse using parse_opt_config_file() in order to get the custom
552
654
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;
655
ret = argp_parse(&argp, argc, argv,
656
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
657
NULL, NULL);
658
switch(ret){
659
case 0:
660
break;
661
case ENOMEM:
662
default:
663
errno = ret;
664
error(0, errno, "argp_parse");
665
exitstatus = EX_OSERR;
666
goto fallback;
667
case EINVAL:
668
exitstatus = EX_USAGE;
557
669
goto fallback;
558
670
}
559
671
565
677
conffp = fopen(AFILE, "r");
566
678
} else {
567
679
conffp = fopen(argfile, "r");
568
}
680
}
569
681
if(conffp != NULL){
570
682
char *org_line = NULL;
571
683
char *p, *arg, *new_arg, *line;
572
684
size_t size = 0;
573
685
const char whitespace_delims[] = " \r\t\f\v\n";
574
686
const char comment_delim[] = "#";
575
687
576
688
custom_argc = 1;
577
689
custom_argv = malloc(sizeof(char*) * 2);
578
690
if(custom_argv == NULL){
579
perror("malloc");
580
exitstatus = EXIT_FAILURE;
691
error(0, errno, "malloc");
692
exitstatus = EX_OSERR;
581
693
goto fallback;
582
694
}
583
695
custom_argv[0] = argv[0];
584
696
custom_argv[1] = NULL;
585
697
586
698
/* for each line in the config file, strip whitespace and ignore
587
699
commented text */
588
700
while(true){
590
702
if(sret == -1){
591
703
break;
592
704
}
593
705
594
706
line = org_line;
595
707
arg = strsep(&line, comment_delim);
596
708
while((p = strsep(&arg, whitespace_delims)) != NULL){
599
711
}
600
712
new_arg = strdup(p);
601
713
if(new_arg == NULL){
602
perror("strdup");
603
exitstatus = EXIT_FAILURE;
714
error(0, errno, "strdup");
715
exitstatus = EX_OSERR;
604
716
free(org_line);
605
717
goto fallback;
606
718
}
607
719
608
720
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;
721
{
722
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
723
char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
724
sizeof(char *));
725
#else
726
char **new_argv = NULL;
727
if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
728
/* overflow */
729
errno = ENOMEM;
730
} else {
731
new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
732
* sizeof(char *));
733
}
734
#endif
735
if(new_argv == NULL){
736
error(0, errno, "reallocarray");
737
exitstatus = EX_OSERR;
738
free(new_arg);
739
free(org_line);
740
goto fallback;
741
} else {
742
custom_argv = new_argv;
743
}
616
744
}
617
745
custom_argv[custom_argc-1] = new_arg;
618
custom_argv[custom_argc] = NULL;
746
custom_argv[custom_argc] = NULL;
619
747
}
620
748
}
749
do {
750
ret = fclose(conffp);
751
} while(ret == EOF and errno == EINTR);
752
if(ret == EOF){
753
error(0, errno, "fclose");
754
exitstatus = EX_IOERR;
755
goto fallback;
756
}
621
757
free(org_line);
622
758
} else {
623
759
/* Check for harmful errors and go to fallback. Other errors might
624
760
not affect opening plugins */
625
761
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
626
perror("fopen");
627
exitstatus = EXIT_FAILURE;
762
error(0, errno, "fopen");
763
exitstatus = EX_OSERR;
628
764
goto fallback;
629
765
}
630
766
}
631
/* If there was any arguments from configuration file,
632
pass them to parser as command arguments */
767
/* If there were any arguments from the configuration file, pass
768
them to parser as command line arguments */
633
769
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;
770
ret = argp_parse(&argp, custom_argc, custom_argv,
771
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
772
NULL, NULL);
773
switch(ret){
774
case 0:
775
break;
776
case ENOMEM:
777
default:
778
errno = ret;
779
error(0, errno, "argp_parse");
780
exitstatus = EX_OSERR;
781
goto fallback;
782
case EINVAL:
783
exitstatus = EX_CONFIG;
639
784
goto fallback;
640
785
}
641
786
}
642
787
643
788
/* Parse actual command line arguments, to let them override the
644
789
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;
790
ret = argp_parse(&argp, argc, argv,
791
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
792
NULL, NULL);
793
switch(ret){
794
case 0:
795
break;
796
case ENOMEM:
797
default:
798
errno = ret;
799
error(0, errno, "argp_parse");
800
exitstatus = EX_OSERR;
801
goto fallback;
802
case EINVAL:
803
exitstatus = EX_USAGE;
804
goto fallback;
805
}
806
807
{
808
char *pluginhelperenv;
809
bool bret = true;
810
ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
811
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
812
if(ret != -1){
813
bret = add_environment(getplugin(NULL), pluginhelperenv, true);
814
}
815
if(ret == -1 or not bret){
816
error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
817
" environment variable to \"%s\" for all plugins\n",
818
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
819
}
820
if(ret != -1){
821
free(pluginhelperenv);
822
}
650
823
}
651
824
652
825
if(debug){
653
for(plugin *p = plugin_list; p != NULL; p=p->next){
826
for(plugin *p = plugin_list; p != NULL; p = p->next){
654
827
fprintf(stderr, "Plugin: %s has %d arguments\n",
655
828
p->name ? p->name : "Global", p->argc - 1);
656
829
for(char **a = p->argv; *a != NULL; a++){
663
836
}
664
837
}
665
838
666
/* Strip permissions down to nobody */
667
setgid(gid);
839
if(getuid() == 0){
840
/* Work around Debian bug #633582:
841
<https://bugs.debian.org/633582> */
842
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
843
if(plugindir_fd == -1){
844
if(errno != ENOENT){
845
error(0, errno, "open(\"" PDIR "\")");
846
}
847
} else {
848
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
849
if(ret == -1){
850
error(0, errno, "fstat");
851
} else {
852
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
853
ret = fchown(plugindir_fd, uid, gid);
854
if(ret == -1){
855
error(0, errno, "fchown");
856
}
857
}
858
}
859
close(plugindir_fd);
860
}
861
}
862
863
/* Lower permissions */
864
ret = setgid(gid);
668
865
if(ret == -1){
669
perror("setgid");
866
error(0, errno, "setgid");
670
867
}
671
868
ret = setuid(uid);
672
869
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 */
870
error(0, errno, "setuid");
871
}
872
873
/* Open plugin directory with close_on_exec flag */
689
874
{
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;
875
dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
876
#ifdef O_CLOEXEC
877
O_CLOEXEC
878
#else /* not O_CLOEXEC */
879
0
880
#endif /* not O_CLOEXEC */
881
);
882
if(dir_fd == -1){
883
error(0, errno, "Could not open plugin dir");
884
exitstatus = EX_UNAVAILABLE;
885
goto fallback;
886
}
887
888
#ifndef O_CLOEXEC
889
/* Set the FD_CLOEXEC flag on the directory */
890
ret = set_cloexec_flag(dir_fd);
891
if(ret < 0){
892
error(0, errno, "set_cloexec_flag");
893
exitstatus = EX_OSERR;
894
goto fallback;
895
}
896
#endif /* O_CLOEXEC */
897
}
898
899
int good_name(const struct dirent * const dirent){
900
const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
901
"*.dpkg-old", "*.dpkg-bak",
902
"*.dpkg-divert", NULL };
903
#ifdef __GNUC__
904
#pragma GCC diagnostic push
905
#pragma GCC diagnostic ignored "-Wcast-qual"
906
#endif
907
for(const char **pat = (const char **)patterns;
908
*pat != NULL; pat++){
909
#ifdef __GNUC__
910
#pragma GCC diagnostic pop
911
#endif
912
if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
913
!= FNM_NOMATCH){
914
if(debug){
915
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
916
" matching pattern %s\n", dirent->d_name, *pat);
917
}
918
return 0;
697
919
}
698
920
}
921
return 1;
922
}
923
924
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
925
alphasort);
926
if(numplugins == -1){
927
error(0, errno, "Could not scan plugin dir");
928
direntries = NULL;
929
exitstatus = EX_OSERR;
930
goto fallback;
699
931
}
700
932
701
933
FD_ZERO(&rfds_all);
702
934
703
935
/* 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");
936
for(int i = 0; i < numplugins; i++){
937
938
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
939
if(plugin_fd == -1){
940
error(0, errno, "Could not open plugin");
941
free(direntries[i]);
771
942
continue;
772
943
}
773
774
ret = stat(filename, &st);
944
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
775
945
if(ret == -1){
776
perror("stat");
777
free(filename);
946
error(0, errno, "stat");
947
close(plugin_fd);
948
free(direntries[i]);
778
949
continue;
779
950
}
780
951
781
952
/* Ignore non-executable files */
782
if(not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
953
if(not S_ISREG(st.st_mode)
954
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
955
X_OK, 0)) != 0)){
783
956
if(debug){
784
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
785
" with bad type or mode\n", filename);
957
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
958
" with bad type or mode\n",
959
plugindir != NULL ? plugindir : PDIR,
960
direntries[i]->d_name);
786
961
}
787
free(filename);
962
close(plugin_fd);
963
free(direntries[i]);
788
964
continue;
789
965
}
790
966
791
plugin *p = getplugin(dirst->d_name);
967
plugin *p = getplugin(direntries[i]->d_name);
792
968
if(p == NULL){
793
perror("getplugin");
794
free(filename);
969
error(0, errno, "getplugin");
970
close(plugin_fd);
971
free(direntries[i]);
795
972
continue;
796
973
}
797
974
if(p->disabled){
798
975
if(debug){
799
976
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
800
dirst->d_name);
977
direntries[i]->d_name);
801
978
}
802
free(filename);
979
close(plugin_fd);
980
free(direntries[i]);
803
981
continue;
804
982
}
805
983
{
808
986
if(g != NULL){
809
987
for(char **a = g->argv + 1; *a != NULL; a++){
810
988
if(not add_argument(p, *a)){
811
perror("add_argument");
989
error(0, errno, "add_argument");
812
990
}
813
991
}
814
992
/* Add global environment variables */
815
993
for(char **e = g->environ; *e != NULL; e++){
816
994
if(not add_environment(p, *e, false)){
817
perror("add_environment");
995
error(0, errno, "add_environment");
818
996
}
819
997
}
820
998
}
821
999
}
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. */
1000
/* If this plugin has any environment variables, we need to
1001
duplicate the environment from this process, too. */
825
1002
if(p->environ[0] != NULL){
826
1003
for(char **e = environ; *e != NULL; e++){
827
1004
if(not add_environment(p, *e, false)){
828
perror("add_environment");
1005
error(0, errno, "add_environment");
829
1006
}
830
1007
}
831
1008
}
832
1009
833
1010
int pipefd[2];
834
ret = pipe(pipefd);
1011
#ifndef O_CLOEXEC
1012
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
1013
#else /* O_CLOEXEC */
1014
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
1015
#endif /* O_CLOEXEC */
835
1016
if(ret == -1){
836
perror("pipe");
837
exitstatus = EXIT_FAILURE;
838
goto fallback;
839
}
1017
error(0, errno, "pipe");
1018
exitstatus = EX_OSERR;
1019
free(direntries[i]);
1020
goto fallback;
1021
}
1022
if(pipefd[0] >= FD_SETSIZE){
1023
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1024
FD_SETSIZE);
1025
close(pipefd[0]);
1026
close(pipefd[1]);
1027
exitstatus = EX_OSERR;
1028
free(direntries[i]);
1029
goto fallback;
1030
}
1031
#ifndef O_CLOEXEC
840
1032
/* Ask OS to automatic close the pipe on exec */
841
1033
ret = set_cloexec_flag(pipefd[0]);
842
1034
if(ret < 0){
843
perror("set_cloexec_flag");
844
exitstatus = EXIT_FAILURE;
1035
error(0, errno, "set_cloexec_flag");
1036
close(pipefd[0]);
1037
close(pipefd[1]);
1038
exitstatus = EX_OSERR;
1039
free(direntries[i]);
845
1040
goto fallback;
846
1041
}
847
1042
ret = set_cloexec_flag(pipefd[1]);
848
1043
if(ret < 0){
849
perror("set_cloexec_flag");
850
exitstatus = EXIT_FAILURE;
1044
error(0, errno, "set_cloexec_flag");
1045
close(pipefd[0]);
1046
close(pipefd[1]);
1047
exitstatus = EX_OSERR;
1048
free(direntries[i]);
851
1049
goto fallback;
852
1050
}
1051
#endif /* not O_CLOEXEC */
853
1052
/* Block SIGCHLD until process is safely in process list */
854
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1053
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1054
&sigchld_action.sa_mask,
1055
NULL));
855
1056
if(ret < 0){
856
perror("sigprocmask");
857
exitstatus = EXIT_FAILURE;
1057
error(0, errno, "sigprocmask");
1058
exitstatus = EX_OSERR;
1059
free(direntries[i]);
858
1060
goto fallback;
859
1061
}
860
1062
/* Starting a new process to be watched */
861
pid_t pid = fork();
1063
pid_t pid;
1064
do {
1065
pid = fork();
1066
} while(pid == -1 and errno == EINTR);
862
1067
if(pid == -1){
863
perror("fork");
864
exitstatus = EXIT_FAILURE;
1068
error(0, errno, "fork");
1069
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1070
&sigchld_action.sa_mask, NULL));
1071
close(pipefd[0]);
1072
close(pipefd[1]);
1073
exitstatus = EX_OSERR;
1074
free(direntries[i]);
865
1075
goto fallback;
866
1076
}
867
1077
if(pid == 0){
868
1078
/* this is the child process */
869
1079
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
870
1080
if(ret < 0){
871
perror("sigaction");
872
_exit(EXIT_FAILURE);
1081
error(0, errno, "sigaction");
1082
_exit(EX_OSERR);
873
1083
}
874
1084
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
875
1085
if(ret < 0){
876
perror("sigprocmask");
877
_exit(EXIT_FAILURE);
1086
error(0, errno, "sigprocmask");
1087
_exit(EX_OSERR);
878
1088
}
879
1089
880
1090
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
881
1091
if(ret == -1){
882
perror("dup2");
883
_exit(EXIT_FAILURE);
1092
error(0, errno, "dup2");
1093
_exit(EX_OSERR);
884
1094
}
885
1095
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
}
1096
if(fexecve(plugin_fd, p->argv,
1097
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1098
error(0, errno, "fexecve for %s/%s",
1099
plugindir != NULL ? plugindir : PDIR,
1100
direntries[i]->d_name);
1101
_exit(EX_OSERR);
901
1102
}
902
1103
/* no return */
903
1104
}
904
1105
/* Parent process */
905
1106
close(pipefd[1]); /* Close unused write end of pipe */
906
free(filename);
907
plugin *new_plugin = getplugin(dirst->d_name);
1107
close(plugin_fd);
1108
plugin *new_plugin = getplugin(direntries[i]->d_name);
908
1109
if(new_plugin == NULL){
909
perror("getplugin");
910
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1110
error(0, errno, "getplugin");
1111
ret = (int)(TEMP_FAILURE_RETRY
1112
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1113
NULL)));
911
1114
if(ret < 0){
912
perror("sigprocmask");
1115
error(0, errno, "sigprocmask");
913
1116
}
914
exitstatus = EXIT_FAILURE;
1117
exitstatus = EX_OSERR;
1118
free(direntries[i]);
915
1119
goto fallback;
916
1120
}
1121
free(direntries[i]);
917
1122
918
1123
new_plugin->pid = pid;
919
1124
new_plugin->fd = pipefd[0];
920
1125
1126
if(debug){
1127
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1128
new_plugin->name, (intmax_t) (new_plugin->pid));
1129
}
1130
921
1131
/* Unblock SIGCHLD so signal handler can be run if this process
922
1132
has already completed */
923
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1133
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1134
&sigchld_action.sa_mask,
1135
NULL));
924
1136
if(ret < 0){
925
perror("sigprocmask");
926
exitstatus = EXIT_FAILURE;
1137
error(0, errno, "sigprocmask");
1138
exitstatus = EX_OSERR;
927
1139
goto fallback;
928
1140
}
929
1141
934
1146
}
935
1147
}
936
1148
937
closedir(dir);
938
dir = NULL;
1149
free(direntries);
1150
direntries = NULL;
1151
close(dir_fd);
1152
dir_fd = -1;
1153
free_plugin(getplugin(NULL));
939
1154
940
1155
for(plugin *p = plugin_list; p != NULL; p = p->next){
941
1156
if(p->pid != 0){
952
1167
while(plugin_list){
953
1168
fd_set rfds = rfds_all;
954
1169
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
955
if(select_ret == -1){
956
perror("select");
957
exitstatus = EXIT_FAILURE;
1170
if(select_ret == -1 and errno != EINTR){
1171
error(0, errno, "select");
1172
exitstatus = EX_OSERR;
958
1173
goto fallback;
959
1174
}
960
1175
/* OK, now either a process completed, or something can be read
966
1181
if(not WIFEXITED(proc->status)
967
1182
or WEXITSTATUS(proc->status) != 0){
968
1183
/* Bad exit by plugin */
969
1184
970
1185
if(debug){
971
1186
if(WIFEXITED(proc->status)){
972
1187
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
975
1190
WEXITSTATUS(proc->status));
976
1191
} else if(WIFSIGNALED(proc->status)){
977
1192
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
978
" signal %d\n", proc->name,
1193
" signal %d: %s\n", proc->name,
979
1194
(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));
1195
WTERMSIG(proc->status),
1196
strsignal(WTERMSIG(proc->status)));
984
1197
}
985
1198
}
986
1199
987
1200
/* Remove the plugin */
988
1201
FD_CLR(proc->fd, &rfds_all);
989
1202
990
1203
/* Block signal while modifying process_list */
991
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1204
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1205
(SIG_BLOCK,
1206
&sigchld_action.sa_mask,
1207
NULL));
992
1208
if(ret < 0){
993
perror("sigprocmask");
994
exitstatus = EXIT_FAILURE;
1209
error(0, errno, "sigprocmask");
1210
exitstatus = EX_OSERR;
995
1211
goto fallback;
996
1212
}
997
1213
1000
1216
proc = next_plugin;
1001
1217
1002
1218
/* We are done modifying process list, so unblock signal */
1003
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1004
NULL);
1219
ret = (int)(TEMP_FAILURE_RETRY
1220
(sigprocmask(SIG_UNBLOCK,
1221
&sigchld_action.sa_mask, NULL)));
1005
1222
if(ret < 0){
1006
perror("sigprocmask");
1007
exitstatus = EXIT_FAILURE;
1223
error(0, errno, "sigprocmask");
1224
exitstatus = EX_OSERR;
1008
1225
goto fallback;
1009
1226
}
1010
1227
1020
1237
bool bret = print_out_password(proc->buffer,
1021
1238
proc->buffer_length);
1022
1239
if(not bret){
1023
perror("print_out_password");
1024
exitstatus = EXIT_FAILURE;
1240
error(0, errno, "print_out_password");
1241
exitstatus = EX_IOERR;
1025
1242
}
1026
1243
goto fallback;
1027
1244
}
1034
1251
}
1035
1252
/* Before reading, make the process' data buffer large enough */
1036
1253
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;
1254
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1255
+ (size_t) BUFFER_SIZE);
1256
if(new_buffer == NULL){
1257
error(0, errno, "malloc");
1258
exitstatus = EX_OSERR;
1042
1259
goto fallback;
1043
1260
}
1261
proc->buffer = new_buffer;
1044
1262
proc->buffer_size += BUFFER_SIZE;
1045
1263
}
1046
1264
/* Read from the process */
1047
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1048
BUFFER_SIZE);
1265
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1266
proc->buffer
1267
+ proc->buffer_length,
1268
BUFFER_SIZE));
1049
1269
if(sret < 0){
1050
1270
/* Read error from this process; ignore the error */
1051
1271
proc = proc->next;
1059
1279
}
1060
1280
}
1061
1281
}
1062
1063
1282
1283
1064
1284
fallback:
1065
1285
1066
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1286
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1287
and exitstatus != EX_OK)){
1067
1288
/* Fallback if all plugins failed, none are found or an error
1068
1289
occured */
1069
1290
bool bret;
1077
1298
}
1078
1299
bret = print_out_password(passwordbuffer, len);
1079
1300
if(not bret){
1080
perror("print_out_password");
1081
exitstatus = EXIT_FAILURE;
1301
error(0, errno, "print_out_password");
1302
exitstatus = EX_IOERR;
1082
1303
}
1083
1304
}
1084
1305
1085
1306
/* Restore old signal handler */
1086
1307
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1087
1308
if(ret == -1){
1088
perror("sigaction");
1089
exitstatus = EXIT_FAILURE;
1309
error(0, errno, "sigaction");
1310
exitstatus = EX_OSERR;
1090
1311
}
1091
1312
1092
1313
if(custom_argv != NULL){
1096
1317
free(custom_argv);
1097
1318
}
1098
1319
1099
if(dir != NULL){
1100
closedir(dir);
1320
free(direntries);
1321
1322
if(dir_fd != -1){
1323
close(dir_fd);
1101
1324
}
1102
1325
1103
1326
/* Kill the processes */
1107
1330
ret = kill(p->pid, SIGTERM);
1108
1331
if(ret == -1 and errno != ESRCH){
1109
1332
/* Set-uid proccesses might not get closed */
1110
perror("kill");
1333
error(0, errno, "kill");
1111
1334
}
1112
1335
}
1113
1336
}
1114
1337
1115
1338
/* Wait for any remaining child processes to terminate */
1116
do{
1339
do {
1117
1340
ret = wait(NULL);
1118
1341
} while(ret >= 0);
1119
1342
if(errno != ECHILD){
1120
perror("wait");
1343
error(0, errno, "wait");
1121
1344
}
1122
1345
1123
1346
free_plugin_list();
1124
1347
1125
1348
free(plugindir);
1349
free(pluginhelperdir);
1126
1350
free(argfile);
1127
1351
1128
1352
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0