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;
89
97
size_t buffer_size;
90
98
size_t buffer_length;
91
99
bool eof;
92
volatile bool completed;
93
volatile int status;
100
volatile sig_atomic_t completed;
101
int status;
94
102
struct plugin *next;
95
103
} plugin;
96
104
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
}
122
138
123
*new_plugin = (plugin) { .name = copy_name,
124
.argc = 1,
125
.disabled = false,
126
.next = plugin_list };
139
*new_plugin = (plugin){ .name = copy_name,
140
.argc = 1,
141
.disabled = false,
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
224
276
status. */
225
277
static void handle_sigchld(__attribute__((unused)) int sig){
278
int old_errno = errno;
226
279
while(true){
227
280
plugin *proc = plugin_list;
228
281
int status;
232
285
break;
233
286
}
234
287
if(pid == -1){
235
if(errno != ECHILD){
236
perror("waitpid");
288
if(errno == ECHILD){
289
/* No child processes */
290
break;
237
291
}
238
/* No child processes */
239
break;
292
error(0, errno, "waitpid");
240
293
}
241
294
242
295
/* A child exited, find it in process_list */
248
301
continue;
249
302
}
250
303
proc->status = status;
251
proc->completed = true;
304
proc->completed = 1;
252
305
}
306
errno = old_errno;
253
307
}
254
308
255
309
/* Prints out a password to stdout */
310
__attribute__((nonnull, warn_unused_result))
256
311
static bool print_out_password(const char *buffer, size_t length){
257
312
ssize_t ret;
258
313
for(size_t written = 0; written < length; written += (size_t)ret){
266
321
}
267
322
268
323
/* Removes and free a plugin from the plugin list */
324
__attribute__((nonnull))
269
325
static void free_plugin(plugin *plugin_node){
270
326
271
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
327
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
272
328
free(*arg);
273
329
}
330
free(plugin_node->name);
274
331
free(plugin_node->argv);
275
332
for(char **env = plugin_node->environ; *env != NULL; env++){
276
333
free(*env);
277
334
}
278
335
free(plugin_node->environ);
279
336
free(plugin_node->buffer);
280
337
281
338
/* Removes the plugin from the singly-linked list */
282
339
if(plugin_node == plugin_list){
283
340
/* First one - simple */
303
360
304
361
int main(int argc, char *argv[]){
305
362
char *plugindir = NULL;
363
char *pluginhelperdir = NULL;
306
364
char *argfile = NULL;
307
365
FILE *conffp;
308
size_t d_name_len;
309
DIR *dir = NULL;
310
struct dirent *dirst;
366
struct dirent **direntries = NULL;
311
367
struct stat st;
312
368
fd_set rfds_all;
313
int ret, numchars, maxfd = 0;
369
int ret, maxfd = 0;
314
370
ssize_t sret;
315
intmax_t tmpmax;
316
371
uid_t uid = 65534;
317
372
gid_t gid = 65534;
318
373
bool debug = false;
322
377
.sa_flags = SA_NOCLDSTOP };
323
378
char **custom_argv = NULL;
324
379
int custom_argc = 0;
380
int dir_fd = -1;
325
381
326
382
/* Establish a signal handler */
327
383
sigemptyset(&sigchld_action.sa_mask);
328
384
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
329
385
if(ret == -1){
330
perror("sigaddset");
331
exitstatus = EXIT_FAILURE;
386
error(0, errno, "sigaddset");
387
exitstatus = EX_OSERR;
332
388
goto fallback;
333
389
}
334
390
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
335
391
if(ret == -1){
336
perror("sigaction");
337
exitstatus = EXIT_FAILURE;
392
error(0, errno, "sigaction");
393
exitstatus = EX_OSERR;
338
394
goto fallback;
339
395
}
340
396
372
428
.doc = "Group ID the plugins will run as", .group = 3 },
373
429
{ .name = "debug", .key = 132,
374
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 },
375
444
{ .name = NULL }
376
445
};
377
446
378
error_t parse_opt(int key, char *arg, __attribute__((unused))
379
struct argp_state *state) {
380
switch(key) {
447
__attribute__((nonnull(3)))
448
error_t parse_opt(int key, char *arg, struct argp_state *state){
449
errno = 0;
450
switch(key){
451
char *tmp;
452
intmax_t tmp_id;
381
453
case 'g': /* --global-options */
382
if(arg != NULL){
383
char *p;
384
while((p = strsep(&arg, ",")) != NULL){
385
if(p[0] == '\0'){
386
continue;
387
}
388
if(not add_argument(getplugin(NULL), p)){
389
perror("add_argument");
390
return ARGP_ERR_UNKNOWN;
454
{
455
char *plugin_option;
456
while((plugin_option = strsep(&arg, ",")) != NULL){
457
if(not add_argument(getplugin(NULL), plugin_option)){
458
break;
391
459
}
392
460
}
461
errno = 0;
393
462
}
394
463
break;
395
464
case 'G': /* --global-env */
396
if(arg == NULL){
397
break;
398
}
399
if(not add_environment(getplugin(NULL), arg, true)){
400
perror("add_environment");
465
if(add_environment(getplugin(NULL), arg, true)){
466
errno = 0;
401
467
}
402
468
break;
403
469
case 'o': /* --options-for */
404
if(arg != NULL){
405
char *p_name = strsep(&arg, ":");
406
if(p_name[0] == '\0' or arg == NULL){
407
break;
408
}
409
char *opt = strsep(&arg, ":");
410
if(opt[0] == '\0' or opt == NULL){
411
break;
412
}
413
char *p;
414
while((p = strsep(&opt, ",")) != NULL){
415
if(p[0] == '\0'){
416
continue;
417
}
418
if(not add_argument(getplugin(p_name), p)){
419
perror("add_argument");
420
return ARGP_ERR_UNKNOWN;
421
}
422
}
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;
423
491
}
424
492
break;
425
493
case 'E': /* --env-for */
426
if(arg == NULL){
427
break;
428
}
429
494
{
430
495
char *envdef = strchr(arg, ':');
431
496
if(envdef == NULL){
497
argp_error(state, "No colon in \"%s\"", arg);
498
errno = EINVAL;
432
499
break;
433
500
}
434
501
*envdef = '\0';
435
if(not add_environment(getplugin(arg), envdef+1, true)){
436
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;
437
510
}
438
511
}
439
512
break;
440
513
case 'd': /* --disable */
441
if(arg != NULL){
514
{
442
515
plugin *p = getplugin(arg);
443
if(p == NULL){
444
return ARGP_ERR_UNKNOWN;
516
if(p != NULL){
517
p->disabled = true;
518
errno = 0;
445
519
}
446
p->disabled = true;
447
520
}
448
521
break;
449
522
case 'e': /* --enable */
450
if(arg != NULL){
523
{
451
524
plugin *p = getplugin(arg);
452
if(p == NULL){
453
return ARGP_ERR_UNKNOWN;
525
if(p != NULL){
526
p->disabled = false;
527
errno = 0;
454
528
}
455
p->disabled = false;
456
529
}
457
530
break;
458
531
case 128: /* --plugin-dir */
459
532
free(plugindir);
460
533
plugindir = strdup(arg);
461
if(plugindir == NULL){
462
perror("strdup");
463
}
534
if(plugindir != NULL){
535
errno = 0;
536
}
464
537
break;
465
538
case 129: /* --config-file */
466
539
/* This is already done by parse_opt_config_file() */
467
540
break;
468
541
case 130: /* --userid */
469
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
470
if(ret < 1 or tmpmax != (uid_t)tmpmax
471
or arg[numchars] != '\0'){
472
fprintf(stderr, "Bad user ID number: \"%s\", using %"
473
PRIdMAX "\n", arg, (intmax_t)uid);
474
} else {
475
uid = (uid_t)tmpmax;
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;
476
548
}
549
uid = (uid_t)tmp_id;
550
errno = 0;
477
551
break;
478
552
case 131: /* --groupid */
479
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
480
if(ret < 1 or tmpmax != (gid_t)tmpmax
481
or arg[numchars] != '\0'){
482
fprintf(stderr, "Bad group ID number: \"%s\", using %"
483
PRIdMAX "\n", arg, (intmax_t)gid);
484
} else {
485
gid = (gid_t)tmpmax;
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;
486
559
}
560
gid = (gid_t)tmp_id;
561
errno = 0;
487
562
break;
488
563
case 132: /* --debug */
489
564
debug = true;
490
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;
491
589
/*
492
590
* When adding more options before this line, remember to also add a
493
591
* "case" to the "parse_opt_config_file" function below.
496
594
/* Cryptsetup always passes an argument, which is an empty
497
595
string if "none" was specified in /etc/crypttab. So if
498
596
argument was empty, we ignore it silently. */
499
if(arg[0] != '\0'){
500
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
597
if(arg[0] == '\0'){
598
break;
501
599
}
502
break;
503
case ARGP_KEY_END:
504
break;
600
#if __GNUC__ >= 7
601
__attribute__((fallthrough));
602
#else
603
/* FALLTHROUGH */
604
#endif
505
605
default:
506
606
return ARGP_ERR_UNKNOWN;
507
607
}
508
return 0;
608
return errno; /* Set to 0 at start */
509
609
}
510
610
511
611
/* This option parser is the same as parse_opt() above, except it
512
612
ignores everything but the --config-file option. */
513
613
error_t parse_opt_config_file(int key, char *arg,
514
614
__attribute__((unused))
515
struct argp_state *state) {
516
switch(key) {
615
struct argp_state *state){
616
errno = 0;
617
switch(key){
517
618
case 'g': /* --global-options */
518
619
case 'G': /* --global-env */
519
620
case 'o': /* --options-for */
525
626
case 129: /* --config-file */
526
627
free(argfile);
527
628
argfile = strdup(arg);
528
if(argfile == NULL){
529
perror("strdup");
629
if(argfile != NULL){
630
errno = 0;
530
631
}
531
break;
632
break;
532
633
case 130: /* --userid */
533
634
case 131: /* --groupid */
534
635
case 132: /* --debug */
636
case 133: /* --plugin-helper-dir */
637
case '?': /* --help */
638
case -3: /* --usage */
639
case 'V': /* --version */
535
640
case ARGP_KEY_ARG:
536
case ARGP_KEY_END:
537
641
break;
538
642
default:
539
643
return ARGP_ERR_UNKNOWN;
540
644
}
541
return 0;
645
return errno;
542
646
}
543
647
544
648
struct argp argp = { .options = options,
548
652
549
653
/* Parse using parse_opt_config_file() in order to get the custom
550
654
config file location, if any. */
551
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
552
if(ret == ARGP_ERR_UNKNOWN){
553
fprintf(stderr, "Unknown error while parsing arguments\n");
554
exitstatus = EXIT_FAILURE;
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;
555
669
goto fallback;
556
670
}
557
671
563
677
conffp = fopen(AFILE, "r");
564
678
} else {
565
679
conffp = fopen(argfile, "r");
566
}
680
}
567
681
if(conffp != NULL){
568
682
char *org_line = NULL;
569
683
char *p, *arg, *new_arg, *line;
570
684
size_t size = 0;
571
685
const char whitespace_delims[] = " \r\t\f\v\n";
572
686
const char comment_delim[] = "#";
573
687
574
688
custom_argc = 1;
575
689
custom_argv = malloc(sizeof(char*) * 2);
576
690
if(custom_argv == NULL){
577
perror("malloc");
578
exitstatus = EXIT_FAILURE;
691
error(0, errno, "malloc");
692
exitstatus = EX_OSERR;
579
693
goto fallback;
580
694
}
581
695
custom_argv[0] = argv[0];
582
696
custom_argv[1] = NULL;
583
697
584
698
/* for each line in the config file, strip whitespace and ignore
585
699
commented text */
586
700
while(true){
588
702
if(sret == -1){
589
703
break;
590
704
}
591
705
592
706
line = org_line;
593
707
arg = strsep(&line, comment_delim);
594
708
while((p = strsep(&arg, whitespace_delims)) != NULL){
597
711
}
598
712
new_arg = strdup(p);
599
713
if(new_arg == NULL){
600
perror("strdup");
601
exitstatus = EXIT_FAILURE;
714
error(0, errno, "strdup");
715
exitstatus = EX_OSERR;
602
716
free(org_line);
603
717
goto fallback;
604
718
}
605
719
606
720
custom_argc += 1;
607
custom_argv = realloc(custom_argv, sizeof(char *)
608
* ((unsigned int) custom_argc + 1));
609
if(custom_argv == NULL){
610
perror("realloc");
611
exitstatus = EXIT_FAILURE;
612
free(org_line);
613
goto fallback;
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
}
614
744
}
615
745
custom_argv[custom_argc-1] = new_arg;
616
custom_argv[custom_argc] = NULL;
746
custom_argv[custom_argc] = NULL;
617
747
}
618
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
}
619
757
free(org_line);
620
758
} else {
621
759
/* Check for harmful errors and go to fallback. Other errors might
622
760
not affect opening plugins */
623
761
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
624
perror("fopen");
625
exitstatus = EXIT_FAILURE;
762
error(0, errno, "fopen");
763
exitstatus = EX_OSERR;
626
764
goto fallback;
627
765
}
628
766
}
629
/* If there was any arguments from configuration file,
630
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 */
631
769
if(custom_argv != NULL){
632
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
633
0, NULL);
634
if(ret == ARGP_ERR_UNKNOWN){
635
fprintf(stderr, "Unknown error while parsing arguments\n");
636
exitstatus = EXIT_FAILURE;
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;
637
784
goto fallback;
638
785
}
639
786
}
640
787
641
788
/* Parse actual command line arguments, to let them override the
642
789
config file */
643
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
644
if(ret == ARGP_ERR_UNKNOWN){
645
fprintf(stderr, "Unknown error while parsing arguments\n");
646
exitstatus = EXIT_FAILURE;
647
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
}
648
823
}
649
824
650
825
if(debug){
651
for(plugin *p = plugin_list; p != NULL; p=p->next){
826
for(plugin *p = plugin_list; p != NULL; p = p->next){
652
827
fprintf(stderr, "Plugin: %s has %d arguments\n",
653
828
p->name ? p->name : "Global", p->argc - 1);
654
829
for(char **a = p->argv; *a != NULL; a++){
661
836
}
662
837
}
663
838
664
/* Strip permissions down to nobody */
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);
865
if(ret == -1){
866
error(0, errno, "setgid");
867
}
665
868
ret = setuid(uid);
666
869
if(ret == -1){
667
perror("setuid");
668
}
669
setgid(gid);
670
if(ret == -1){
671
perror("setgid");
672
}
673
674
if(plugindir == NULL){
675
dir = opendir(PDIR);
676
} else {
677
dir = opendir(plugindir);
678
}
679
680
if(dir == NULL){
681
perror("Could not open plugin dir");
682
exitstatus = EXIT_FAILURE;
683
goto fallback;
684
}
685
686
/* Set the FD_CLOEXEC flag on the directory, if possible */
870
error(0, errno, "setuid");
871
}
872
873
/* Open plugin directory with close_on_exec flag */
687
874
{
688
int dir_fd = dirfd(dir);
689
if(dir_fd >= 0){
690
ret = set_cloexec_flag(dir_fd);
691
if(ret < 0){
692
perror("set_cloexec_flag");
693
exitstatus = EXIT_FAILURE;
694
goto fallback;
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;
695
919
}
696
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;
697
931
}
698
932
699
933
FD_ZERO(&rfds_all);
700
934
701
935
/* Read and execute any executable in the plugin directory*/
702
while(true){
703
dirst = readdir(dir);
704
705
/* All directory entries have been processed */
706
if(dirst == NULL){
707
if(errno == EBADF){
708
perror("readdir");
709
exitstatus = EXIT_FAILURE;
710
goto fallback;
711
}
712
break;
713
}
714
715
d_name_len = strlen(dirst->d_name);
716
717
/* Ignore dotfiles, backup files and other junk */
718
{
719
bool bad_name = false;
720
721
const char const *bad_prefixes[] = { ".", "#", NULL };
722
723
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
724
".dpkg-old",
725
".dpkg-bak",
726
".dpkg-divert", NULL };
727
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
728
size_t pre_len = strlen(*pre);
729
if((d_name_len >= pre_len)
730
and strncmp((dirst->d_name), *pre, pre_len) == 0){
731
if(debug){
732
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
733
" with bad prefix %s\n", dirst->d_name, *pre);
734
}
735
bad_name = true;
736
break;
737
}
738
}
739
if(bad_name){
740
continue;
741
}
742
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
743
size_t suf_len = strlen(*suf);
744
if((d_name_len >= suf_len)
745
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
746
== 0)){
747
if(debug){
748
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
749
" with bad suffix %s\n", dirst->d_name, *suf);
750
}
751
bad_name = true;
752
break;
753
}
754
}
755
756
if(bad_name){
757
continue;
758
}
759
}
760
761
char *filename;
762
if(plugindir == NULL){
763
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
764
} else {
765
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
766
}
767
if(ret < 0){
768
perror("asprintf");
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]);
769
942
continue;
770
943
}
771
772
ret = stat(filename, &st);
944
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
773
945
if(ret == -1){
774
perror("stat");
775
free(filename);
946
error(0, errno, "stat");
947
close(plugin_fd);
948
free(direntries[i]);
776
949
continue;
777
950
}
778
951
779
952
/* Ignore non-executable files */
780
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)){
781
956
if(debug){
782
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
783
" 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);
784
961
}
785
free(filename);
962
close(plugin_fd);
963
free(direntries[i]);
786
964
continue;
787
965
}
788
966
789
plugin *p = getplugin(dirst->d_name);
967
plugin *p = getplugin(direntries[i]->d_name);
790
968
if(p == NULL){
791
perror("getplugin");
792
free(filename);
969
error(0, errno, "getplugin");
970
close(plugin_fd);
971
free(direntries[i]);
793
972
continue;
794
973
}
795
974
if(p->disabled){
796
975
if(debug){
797
976
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
798
dirst->d_name);
977
direntries[i]->d_name);
799
978
}
800
free(filename);
979
close(plugin_fd);
980
free(direntries[i]);
801
981
continue;
802
982
}
803
983
{
806
986
if(g != NULL){
807
987
for(char **a = g->argv + 1; *a != NULL; a++){
808
988
if(not add_argument(p, *a)){
809
perror("add_argument");
989
error(0, errno, "add_argument");
810
990
}
811
991
}
812
992
/* Add global environment variables */
813
993
for(char **e = g->environ; *e != NULL; e++){
814
994
if(not add_environment(p, *e, false)){
815
perror("add_environment");
995
error(0, errno, "add_environment");
816
996
}
817
997
}
818
998
}
819
999
}
820
/* If this plugin has any environment variables, we will call
821
using execve and need to duplicate the environment from this
822
process, too. */
1000
/* If this plugin has any environment variables, we need to
1001
duplicate the environment from this process, too. */
823
1002
if(p->environ[0] != NULL){
824
1003
for(char **e = environ; *e != NULL; e++){
825
1004
if(not add_environment(p, *e, false)){
826
perror("add_environment");
1005
error(0, errno, "add_environment");
827
1006
}
828
1007
}
829
1008
}
830
1009
831
1010
int pipefd[2];
832
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 */
833
1016
if(ret == -1){
834
perror("pipe");
835
exitstatus = EXIT_FAILURE;
836
goto fallback;
837
}
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
838
1032
/* Ask OS to automatic close the pipe on exec */
839
1033
ret = set_cloexec_flag(pipefd[0]);
840
1034
if(ret < 0){
841
perror("set_cloexec_flag");
842
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]);
843
1040
goto fallback;
844
1041
}
845
1042
ret = set_cloexec_flag(pipefd[1]);
846
1043
if(ret < 0){
847
perror("set_cloexec_flag");
848
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]);
849
1049
goto fallback;
850
1050
}
1051
#endif /* not O_CLOEXEC */
851
1052
/* Block SIGCHLD until process is safely in process list */
852
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));
853
1056
if(ret < 0){
854
perror("sigprocmask");
855
exitstatus = EXIT_FAILURE;
1057
error(0, errno, "sigprocmask");
1058
exitstatus = EX_OSERR;
1059
free(direntries[i]);
856
1060
goto fallback;
857
1061
}
858
1062
/* Starting a new process to be watched */
859
pid_t pid = fork();
1063
pid_t pid;
1064
do {
1065
pid = fork();
1066
} while(pid == -1 and errno == EINTR);
860
1067
if(pid == -1){
861
perror("fork");
862
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]);
863
1075
goto fallback;
864
1076
}
865
1077
if(pid == 0){
866
1078
/* this is the child process */
867
1079
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
868
1080
if(ret < 0){
869
perror("sigaction");
870
_exit(EXIT_FAILURE);
1081
error(0, errno, "sigaction");
1082
_exit(EX_OSERR);
871
1083
}
872
1084
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
873
1085
if(ret < 0){
874
perror("sigprocmask");
875
_exit(EXIT_FAILURE);
1086
error(0, errno, "sigprocmask");
1087
_exit(EX_OSERR);
876
1088
}
877
1089
878
1090
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
879
1091
if(ret == -1){
880
perror("dup2");
881
_exit(EXIT_FAILURE);
1092
error(0, errno, "dup2");
1093
_exit(EX_OSERR);
882
1094
}
883
1095
884
if(dirfd(dir) < 0){
885
/* If dir has no file descriptor, we could not set FD_CLOEXEC
886
above and must now close it manually here. */
887
closedir(dir);
888
}
889
if(p->environ[0] == NULL){
890
if(execv(filename, p->argv) < 0){
891
perror("execv");
892
_exit(EXIT_FAILURE);
893
}
894
} else {
895
if(execve(filename, p->argv, p->environ) < 0){
896
perror("execve");
897
_exit(EXIT_FAILURE);
898
}
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);
899
1102
}
900
1103
/* no return */
901
1104
}
902
1105
/* Parent process */
903
1106
close(pipefd[1]); /* Close unused write end of pipe */
904
free(filename);
905
plugin *new_plugin = getplugin(dirst->d_name);
1107
close(plugin_fd);
1108
plugin *new_plugin = getplugin(direntries[i]->d_name);
906
1109
if(new_plugin == NULL){
907
perror("getplugin");
908
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)));
909
1114
if(ret < 0){
910
perror("sigprocmask");
1115
error(0, errno, "sigprocmask");
911
1116
}
912
exitstatus = EXIT_FAILURE;
1117
exitstatus = EX_OSERR;
1118
free(direntries[i]);
913
1119
goto fallback;
914
1120
}
1121
free(direntries[i]);
915
1122
916
1123
new_plugin->pid = pid;
917
1124
new_plugin->fd = pipefd[0];
918
1125
1126
if(debug){
1127
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1128
new_plugin->name, (intmax_t) (new_plugin->pid));
1129
}
1130
919
1131
/* Unblock SIGCHLD so signal handler can be run if this process
920
1132
has already completed */
921
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));
922
1136
if(ret < 0){
923
perror("sigprocmask");
924
exitstatus = EXIT_FAILURE;
1137
error(0, errno, "sigprocmask");
1138
exitstatus = EX_OSERR;
925
1139
goto fallback;
926
1140
}
927
1141
932
1146
}
933
1147
}
934
1148
935
closedir(dir);
936
dir = NULL;
1149
free(direntries);
1150
direntries = NULL;
1151
close(dir_fd);
1152
dir_fd = -1;
1153
free_plugin(getplugin(NULL));
937
1154
938
1155
for(plugin *p = plugin_list; p != NULL; p = p->next){
939
1156
if(p->pid != 0){
950
1167
while(plugin_list){
951
1168
fd_set rfds = rfds_all;
952
1169
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
953
if(select_ret == -1){
954
perror("select");
955
exitstatus = EXIT_FAILURE;
1170
if(select_ret == -1 and errno != EINTR){
1171
error(0, errno, "select");
1172
exitstatus = EX_OSERR;
956
1173
goto fallback;
957
1174
}
958
1175
/* OK, now either a process completed, or something can be read
959
1176
from one of them */
960
1177
for(plugin *proc = plugin_list; proc != NULL;){
961
1178
/* Is this process completely done? */
962
if(proc->eof and proc->completed){
1179
if(proc->completed and proc->eof){
963
1180
/* Only accept the plugin output if it exited cleanly */
964
1181
if(not WIFEXITED(proc->status)
965
1182
or WEXITSTATUS(proc->status) != 0){
966
1183
/* Bad exit by plugin */
967
1184
968
1185
if(debug){
969
1186
if(WIFEXITED(proc->status)){
970
fprintf(stderr, "Plugin %" PRIdMAX " exited with status"
971
" %d\n", (intmax_t) (proc->pid),
1187
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1188
" status %d\n", proc->name,
1189
(intmax_t) (proc->pid),
972
1190
WEXITSTATUS(proc->status));
973
} else if(WIFSIGNALED(proc->status)) {
974
fprintf(stderr, "Plugin %" PRIdMAX " killed by signal"
975
" %d\n", (intmax_t) (proc->pid),
976
WTERMSIG(proc->status));
977
} else if(WCOREDUMP(proc->status)){
978
fprintf(stderr, "Plugin %" PRIdMAX " dumped core\n",
979
(intmax_t) (proc->pid));
1191
} else if(WIFSIGNALED(proc->status)){
1192
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1193
" signal %d: %s\n", proc->name,
1194
(intmax_t) (proc->pid),
1195
WTERMSIG(proc->status),
1196
strsignal(WTERMSIG(proc->status)));
980
1197
}
981
1198
}
982
1199
983
1200
/* Remove the plugin */
984
1201
FD_CLR(proc->fd, &rfds_all);
985
1202
986
1203
/* Block signal while modifying process_list */
987
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));
988
1208
if(ret < 0){
989
perror("sigprocmask");
990
exitstatus = EXIT_FAILURE;
1209
error(0, errno, "sigprocmask");
1210
exitstatus = EX_OSERR;
991
1211
goto fallback;
992
1212
}
993
1213
996
1216
proc = next_plugin;
997
1217
998
1218
/* We are done modifying process list, so unblock signal */
999
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1000
NULL);
1219
ret = (int)(TEMP_FAILURE_RETRY
1220
(sigprocmask(SIG_UNBLOCK,
1221
&sigchld_action.sa_mask, NULL)));
1001
1222
if(ret < 0){
1002
perror("sigprocmask");
1003
exitstatus = EXIT_FAILURE;
1223
error(0, errno, "sigprocmask");
1224
exitstatus = EX_OSERR;
1004
1225
goto fallback;
1005
1226
}
1006
1227
1016
1237
bool bret = print_out_password(proc->buffer,
1017
1238
proc->buffer_length);
1018
1239
if(not bret){
1019
perror("print_out_password");
1020
exitstatus = EXIT_FAILURE;
1240
error(0, errno, "print_out_password");
1241
exitstatus = EX_IOERR;
1021
1242
}
1022
1243
goto fallback;
1023
1244
}
1030
1251
}
1031
1252
/* Before reading, make the process' data buffer large enough */
1032
1253
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1033
proc->buffer = realloc(proc->buffer, proc->buffer_size
1034
+ (size_t) BUFFER_SIZE);
1035
if(proc->buffer == NULL){
1036
perror("malloc");
1037
exitstatus = EXIT_FAILURE;
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;
1038
1259
goto fallback;
1039
1260
}
1261
proc->buffer = new_buffer;
1040
1262
proc->buffer_size += BUFFER_SIZE;
1041
1263
}
1042
1264
/* Read from the process */
1043
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1044
BUFFER_SIZE);
1265
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1266
proc->buffer
1267
+ proc->buffer_length,
1268
BUFFER_SIZE));
1045
1269
if(sret < 0){
1046
1270
/* Read error from this process; ignore the error */
1047
1271
proc = proc->next;
1055
1279
}
1056
1280
}
1057
1281
}
1058
1059
1282
1283
1060
1284
fallback:
1061
1285
1062
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1286
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1287
and exitstatus != EX_OK)){
1063
1288
/* Fallback if all plugins failed, none are found or an error
1064
1289
occured */
1065
1290
bool bret;
1073
1298
}
1074
1299
bret = print_out_password(passwordbuffer, len);
1075
1300
if(not bret){
1076
perror("print_out_password");
1077
exitstatus = EXIT_FAILURE;
1301
error(0, errno, "print_out_password");
1302
exitstatus = EX_IOERR;
1078
1303
}
1079
1304
}
1080
1305
1081
1306
/* Restore old signal handler */
1082
1307
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1083
1308
if(ret == -1){
1084
perror("sigaction");
1085
exitstatus = EXIT_FAILURE;
1309
error(0, errno, "sigaction");
1310
exitstatus = EX_OSERR;
1086
1311
}
1087
1312
1088
1313
if(custom_argv != NULL){
1092
1317
free(custom_argv);
1093
1318
}
1094
1319
1095
if(dir != NULL){
1096
closedir(dir);
1320
free(direntries);
1321
1322
if(dir_fd != -1){
1323
close(dir_fd);
1097
1324
}
1098
1325
1099
1326
/* Kill the processes */
1103
1330
ret = kill(p->pid, SIGTERM);
1104
1331
if(ret == -1 and errno != ESRCH){
1105
1332
/* Set-uid proccesses might not get closed */
1106
perror("kill");
1333
error(0, errno, "kill");
1107
1334
}
1108
1335
}
1109
1336
}
1110
1337
1111
1338
/* Wait for any remaining child processes to terminate */
1112
do{
1339
do {
1113
1340
ret = wait(NULL);
1114
1341
} while(ret >= 0);
1115
1342
if(errno != ECHILD){
1116
perror("wait");
1343
error(0, errno, "wait");
1117
1344
}
1118
1345
1119
1346
free_plugin_list();
1120
1347
1121
1348
free(plugindir);
1349
free(pluginhelperdir);
1122
1350
free(argfile);
1123
1351
1124
1352
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0