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 1237
- compare with another revision
- download diff
- download tarball
- view history from revision 1237
- Committer: Teddy Hogeborn
- Date: 2021-02-03 23:10:42 UTC
- Revision ID: teddy@recompile.se-20210203231042-2z3egrvpo1zt7nej
mandos-ctl: Fix bad test for command.Remove and related minor issues
The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server. But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing. Fix this.
In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).
Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.
* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
original "clients" dict, and loop over those instead. Add assertion
that all clients were indeed removed. Also fix the code which looks
for the Remove command, which now needs to actually work.
(TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
assertion that there are still clients before looping over them.
(TestPropertySetterCmd.runTest): Add assertion that the list of
values to get is not empty before looping over them. Also add check
that there are still clients before looping over clients.
The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server. But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing. Fix this.
In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).
Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.
* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
original "clients" dict, and loop over those instead. Add assertion
that all clients were indeed removed. Also fix the code which looks
for the Remove command, which now needs to actually work.
(TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
assertion that there are still clients before looping over them.
(TestPropertySetterCmd.runTest): Add assertion that the list of
values to get is not empty before looping over them. Also add check
that there are still clients before looping over clients.
- 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
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-2021 Teddy Hogeborn
6
* Copyright © 2008-2021 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
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
26
asprintf() */
26
#define _GNU_SOURCE /* strchrnul(), TEMP_FAILURE_RETRY(),
27
getline(), asprintf(), O_CLOEXEC,
28
scandirat(), pipe2() */
29
#include <argp.h> /* argp_program_version,
30
argp_program_bug_address,
31
struct argp_option,
32
struct argp_state, argp_error(),
33
ARGP_NO_EXIT, argp_state_help,
34
ARGP_HELP_STD_HELP,
35
ARGP_HELP_USAGE, ARGP_HELP_EXIT_OK,
36
ARGP_KEY_ARG, ARGP_ERR_UNKNOWN,
37
struct argp, argp_parse(),
38
ARGP_IN_ORDER, ARGP_NO_HELP */
39
#include <stdbool.h> /* bool, false, true */
40
#include <sys/types.h> /* pid_t, sig_atomic_t, uid_t, gid_t,
41
getuid(), setgid(), setuid() */
27
42
#include <stddef.h> /* size_t, NULL */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
29
EXIT_SUCCESS, realloc() */
30
#include <stdbool.h> /* bool, true, false */
31
#include <stdio.h> /* perror, fileno(), fprintf(),
32
stderr, STDOUT_FILENO */
33
#include <sys/types.h> /* DIR, opendir(), stat(), struct
34
stat, waitpid(), WIFEXITED(),
35
WEXITSTATUS(), wait(), pid_t,
36
uid_t, gid_t, getuid(), getgid(),
37
dirfd() */
38
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
39
FD_SET(), FD_ISSET(), FD_CLR */
40
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
41
WEXITSTATUS(), WTERMSIG(),
42
WCOREDUMP() */
43
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
44
#include <iso646.h> /* and, or, not */
45
#include <dirent.h> /* DIR, struct dirent, opendir(),
46
readdir(), closedir(), dirfd() */
47
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
48
fcntl(), setuid(), setgid(),
49
F_GETFD, F_SETFD, FD_CLOEXEC,
50
access(), pipe(), fork(), close()
51
dup2(), STDOUT_FILENO, _exit(),
52
execv(), write(), read(),
53
close() */
43
#include <iso646.h> /* or, and, not */
44
#include <string.h> /* strcmp(), strdup(), strchrnul(),
45
strncmp(), strlen(), strcpy(),
46
strsep(), strchr(), strsignal() */
47
#include <stdlib.h> /* malloc(), free(), reallocarray(),
48
realloc(), EXIT_SUCCESS */
49
#include <errno.h> /* errno, EINTR, ENOMEM, ECHILD,
50
error_t, EINVAL, EMFILE, ENFILE,
51
ENOENT, ESRCH */
52
#include <stdint.h> /* SIZE_MAX */
53
#define _GNU_SOURCE /* strchrnul(), TEMP_FAILURE_RETRY(),
54
getline(), asprintf(), O_CLOEXEC,
55
scandirat(), pipe2() */
56
#include <unistd.h> /* TEMP_FAILURE_RETRY(), ssize_t,
57
write(), STDOUT_FILENO, uid_t,
58
gid_t, getuid(), fchown(), close(),
59
symlink(), setgid(), setuid(),
60
faccessat(), X_OK, pipe(), pipe2(),
61
fork(), _exit(), dup2(), fexecve(),
62
read(), getpass() */
54
63
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
55
FD_CLOEXEC */
56
#include <string.h> /* strsep, strlen(), asprintf(),
57
strsignal() */
58
#include <errno.h> /* errno */
59
#include <argp.h> /* struct argp_option, struct
60
argp_state, struct argp,
61
argp_parse(), ARGP_ERR_UNKNOWN,
62
ARGP_KEY_END, ARGP_KEY_ARG,
63
error_t */
64
#include <signal.h> /* struct sigaction, sigemptyset(),
65
sigaddset(), sigaction(),
66
sigprocmask(), SIG_BLOCK, SIGCHLD,
67
SIG_UNBLOCK, kill(), sig_atomic_t
68
*/
69
#include <errno.h> /* errno, EBADF */
70
#include <inttypes.h> /* intmax_t, PRIdMAX, strtoimax() */
64
FD_CLOEXEC, open(), O_RDONLY,
65
O_CLOEXEC, openat() */
66
#include <sys/wait.h> /* waitpid(), WNOHANG, WIFEXITED(),
67
WEXITSTATUS(), WIFSIGNALED(),
68
WTERMSIG(), wait() */
69
#include <error.h> /* error() */
70
#include <stdio.h> /* FILE, fprintf(), fopen(),
71
getline(), fclose(), EOF,
72
asprintf(), stderr */
73
#include <dirent.h> /* struct dirent, scandirat(),
74
alphasort() */
75
#include <sys/stat.h> /* struct stat, fstat(), S_ISDIR(),
76
lstat(), S_ISREG() */
77
#include <sys/select.h> /* fd_set, FD_ZERO(), FD_SETSIZE,
78
FD_SET(), select(), FD_CLR(),
79
FD_ISSET() */
80
#include <signal.h> /* struct sigaction, SA_NOCLDSTOP,
81
sigemptyset(), sigaddset(),
82
SIGCHLD, sigprocmask(), SIG_BLOCK,
83
SIG_UNBLOCK, kill(), SIGTERM */
84
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,
85
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
86
#include <inttypes.h> /* intmax_t, strtoimax(), PRIdMAX */
87
#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME,
88
FNM_PERIOD, FNM_NOMATCH */
71
89
72
90
#define BUFFER_SIZE 256
73
91
74
92
#define PDIR "/lib/mandos/plugins.d"
93
#define PHDIR "/lib/mandos/plugin-helpers"
75
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
76
95
77
96
const char *argp_program_version = "plugin-runner " VERSION;
78
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
79
98
80
99
typedef struct plugin{
81
100
char *name; /* can be NULL or any plugin name */
101
120
102
121
/* Gets an existing plugin based on name,
103
122
or if none is found, creates a new one */
123
__attribute__((warn_unused_result))
104
124
static plugin *getplugin(char *name){
105
/* Check for exiting plugin with that name */
125
/* Check for existing plugin with that name */
106
126
for(plugin *p = plugin_list; p != NULL; p = p->next){
107
127
if((p->name == name)
108
128
or (p->name and name and (strcmp(p->name, name) == 0))){
123
143
copy_name = strdup(name);
124
144
} while(copy_name == NULL and errno == EINTR);
125
145
if(copy_name == NULL){
146
int e = errno;
126
147
free(new_plugin);
148
errno = e;
127
149
return NULL;
128
150
}
129
151
}
137
159
new_plugin->argv = malloc(sizeof(char *) * 2);
138
160
} while(new_plugin->argv == NULL and errno == EINTR);
139
161
if(new_plugin->argv == NULL){
162
int e = errno;
140
163
free(copy_name);
141
164
free(new_plugin);
165
errno = e;
142
166
return NULL;
143
167
}
144
168
new_plugin->argv[0] = copy_name;
148
172
new_plugin->environ = malloc(sizeof(char *));
149
173
} while(new_plugin->environ == NULL and errno == EINTR);
150
174
if(new_plugin->environ == NULL){
175
int e = errno;
151
176
free(copy_name);
152
177
free(new_plugin->argv);
153
178
free(new_plugin);
179
errno = e;
154
180
return NULL;
155
181
}
156
182
new_plugin->environ[0] = NULL;
161
187
}
162
188
163
189
/* Helper function for add_argument and add_environment */
190
__attribute__((nonnull, warn_unused_result))
164
191
static bool add_to_char_array(const char *new, char ***array,
165
192
int *len){
166
193
/* Resize the pointed-to array to hold one more pointer */
194
char **new_array = NULL;
167
195
do {
168
*array = realloc(*array, sizeof(char *)
169
* (size_t) ((*len) + 2));
170
} while(*array == NULL and errno == EINTR);
196
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
197
new_array = reallocarray(*array, (size_t)((*len) + 2),
198
sizeof(char *));
199
#else
200
if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
201
/* overflow */
202
new_array = NULL;
203
errno = ENOMEM;
204
} else {
205
new_array = realloc(*array, (size_t)((*len) + 2)
206
* sizeof(char *));
207
}
208
#endif
209
} while(new_array == NULL and errno == EINTR);
171
210
/* Malloc check */
172
if(*array == NULL){
211
if(new_array == NULL){
173
212
return false;
174
213
}
214
*array = new_array;
175
215
/* Make a copy of the new string */
176
216
char *copy;
177
217
do {
189
229
}
190
230
191
231
/* Add to a plugin's argument vector */
232
__attribute__((nonnull(2), warn_unused_result))
192
233
static bool add_argument(plugin *p, const char *arg){
193
234
if(p == NULL){
194
235
return false;
197
238
}
198
239
199
240
/* Add to a plugin's environment */
241
__attribute__((nonnull(2), warn_unused_result))
200
242
static bool add_environment(plugin *p, const char *def, bool replace){
201
243
if(p == NULL){
202
244
return false;
204
246
/* namelen = length of name of environment variable */
205
247
size_t namelen = (size_t)(strchrnul(def, '=') - def);
206
248
/* Search for this environment variable */
207
for(char **e = p->environ; *e != NULL; e++){
208
if(strncmp(*e, def, namelen + 1) == 0){
249
for(char **envdef = p->environ; *envdef != NULL; envdef++){
250
if(strncmp(*envdef, def, namelen + 1) == 0){
209
251
/* It already exists */
210
252
if(replace){
211
char *new;
253
char *new_envdef;
212
254
do {
213
new = realloc(*e, strlen(def) + 1);
214
} while(new == NULL and errno == EINTR);
215
if(new == NULL){
255
new_envdef = realloc(*envdef, strlen(def) + 1);
256
} while(new_envdef == NULL and errno == EINTR);
257
if(new_envdef == NULL){
216
258
return false;
217
259
}
218
*e = new;
219
strcpy(*e, def);
260
*envdef = new_envdef;
261
strcpy(*envdef, def);
220
262
}
221
263
return true;
222
264
}
224
266
return add_to_char_array(def, &(p->environ), &(p->envc));
225
267
}
226
268
269
#ifndef O_CLOEXEC
227
270
/*
228
271
* Based on the example in the GNU LibC manual chapter 13.13 "File
229
272
* Descriptor Flags".
230
273
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
231
274
*/
275
__attribute__((warn_unused_result))
232
276
static int set_cloexec_flag(int fd){
233
277
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
234
278
/* If reading the flags failed, return error indication now. */
239
283
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
240
284
ret | FD_CLOEXEC));
241
285
}
286
#endif /* not O_CLOEXEC */
242
287
243
288
244
289
/* Mark processes as completed when they exit, and save their exit
258
303
/* No child processes */
259
304
break;
260
305
}
261
perror("waitpid");
306
error(0, errno, "waitpid");
262
307
}
263
308
264
309
/* A child exited, find it in process_list */
276
321
}
277
322
278
323
/* Prints out a password to stdout */
324
__attribute__((nonnull, warn_unused_result))
279
325
static bool print_out_password(const char *buffer, size_t length){
280
326
ssize_t ret;
281
327
for(size_t written = 0; written < length; written += (size_t)ret){
289
335
}
290
336
291
337
/* Removes and free a plugin from the plugin list */
338
__attribute__((nonnull))
292
339
static void free_plugin(plugin *plugin_node){
293
340
294
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
341
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
295
342
free(*arg);
296
343
}
344
free(plugin_node->name);
297
345
free(plugin_node->argv);
298
346
for(char **env = plugin_node->environ; *env != NULL; env++){
299
347
free(*env);
326
374
327
375
int main(int argc, char *argv[]){
328
376
char *plugindir = NULL;
377
char *pluginhelperdir = NULL;
329
378
char *argfile = NULL;
330
379
FILE *conffp;
331
size_t d_name_len;
332
DIR *dir = NULL;
333
struct dirent *dirst;
380
struct dirent **direntries = NULL;
334
381
struct stat st;
335
382
fd_set rfds_all;
336
383
int ret, maxfd = 0;
344
391
.sa_flags = SA_NOCLDSTOP };
345
392
char **custom_argv = NULL;
346
393
int custom_argc = 0;
394
int dir_fd = -1;
347
395
348
396
/* Establish a signal handler */
349
397
sigemptyset(&sigchld_action.sa_mask);
350
398
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
351
399
if(ret == -1){
352
perror("sigaddset");
353
exitstatus = EXIT_FAILURE;
400
error(0, errno, "sigaddset");
401
exitstatus = EX_OSERR;
354
402
goto fallback;
355
403
}
356
404
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
357
405
if(ret == -1){
358
perror("sigaction");
359
exitstatus = EXIT_FAILURE;
406
error(0, errno, "sigaction");
407
exitstatus = EX_OSERR;
360
408
goto fallback;
361
409
}
362
410
394
442
.doc = "Group ID the plugins will run as", .group = 3 },
395
443
{ .name = "debug", .key = 132,
396
444
.doc = "Debug mode", .group = 4 },
445
{ .name = "plugin-helper-dir", .key = 133,
446
.arg = "DIRECTORY",
447
.doc = "Specify a different plugin helper directory",
448
.group = 2 },
449
/*
450
* These reproduce what we would get without ARGP_NO_HELP
451
*/
452
{ .name = "help", .key = '?',
453
.doc = "Give this help list", .group = -1 },
454
{ .name = "usage", .key = -3,
455
.doc = "Give a short usage message", .group = -1 },
456
{ .name = "version", .key = 'V',
457
.doc = "Print program version", .group = -1 },
397
458
{ .name = NULL }
398
459
};
399
460
400
error_t parse_opt(int key, char *arg, __attribute__((unused))
401
struct argp_state *state){
461
__attribute__((nonnull(3)))
462
error_t parse_opt(int key, char *arg, struct argp_state *state){
463
errno = 0;
402
464
switch(key){
403
465
char *tmp;
404
intmax_t tmpmax;
466
intmax_t tmp_id;
405
467
case 'g': /* --global-options */
406
if(arg != NULL){
468
{
407
469
char *plugin_option;
408
470
while((plugin_option = strsep(&arg, ",")) != NULL){
409
if(plugin_option[0] == '\0'){
410
continue;
411
}
412
471
if(not add_argument(getplugin(NULL), plugin_option)){
413
perror("add_argument");
414
return ARGP_ERR_UNKNOWN;
472
break;
415
473
}
416
474
}
475
errno = 0;
417
476
}
418
477
break;
419
478
case 'G': /* --global-env */
420
if(arg == NULL){
421
break;
422
}
423
if(not add_environment(getplugin(NULL), arg, true)){
424
perror("add_environment");
479
if(add_environment(getplugin(NULL), arg, true)){
480
errno = 0;
425
481
}
426
482
break;
427
483
case 'o': /* --options-for */
428
if(arg != NULL){
429
char *plugin_name = strsep(&arg, ":");
430
if(plugin_name[0] == '\0'){
431
break;
432
}
433
char *plugin_option;
434
while((plugin_option = strsep(&arg, ",")) != NULL){
435
if(not add_argument(getplugin(plugin_name), plugin_option)){
436
perror("add_argument");
437
return ARGP_ERR_UNKNOWN;
484
{
485
char *option_list = strchr(arg, ':');
486
if(option_list == NULL){
487
argp_error(state, "No colon in \"%s\"", arg);
488
errno = EINVAL;
489
break;
490
}
491
*option_list = '\0';
492
option_list++;
493
if(arg[0] == '\0'){
494
argp_error(state, "Empty plugin name");
495
errno = EINVAL;
496
break;
497
}
498
char *option;
499
while((option = strsep(&option_list, ",")) != NULL){
500
if(not add_argument(getplugin(arg), option)){
501
break;
438
502
}
439
503
}
504
errno = 0;
440
505
}
441
506
break;
442
507
case 'E': /* --env-for */
443
if(arg == NULL){
444
break;
445
}
446
508
{
447
509
char *envdef = strchr(arg, ':');
448
510
if(envdef == NULL){
511
argp_error(state, "No colon in \"%s\"", arg);
512
errno = EINVAL;
449
513
break;
450
514
}
451
515
*envdef = '\0';
452
if(not add_environment(getplugin(arg), envdef+1, true)){
453
perror("add_environment");
516
envdef++;
517
if(arg[0] == '\0'){
518
argp_error(state, "Empty plugin name");
519
errno = EINVAL;
520
break;
521
}
522
if(add_environment(getplugin(arg), envdef, true)){
523
errno = 0;
454
524
}
455
525
}
456
526
break;
457
527
case 'd': /* --disable */
458
if(arg != NULL){
528
{
459
529
plugin *p = getplugin(arg);
460
if(p == NULL){
461
return ARGP_ERR_UNKNOWN;
530
if(p != NULL){
531
p->disabled = true;
532
errno = 0;
462
533
}
463
p->disabled = true;
464
534
}
465
535
break;
466
536
case 'e': /* --enable */
467
if(arg != NULL){
537
{
468
538
plugin *p = getplugin(arg);
469
if(p == NULL){
470
return ARGP_ERR_UNKNOWN;
539
if(p != NULL){
540
p->disabled = false;
541
errno = 0;
471
542
}
472
p->disabled = false;
473
543
}
474
544
break;
475
545
case 128: /* --plugin-dir */
476
546
free(plugindir);
477
547
plugindir = strdup(arg);
478
if(plugindir == NULL){
479
perror("strdup");
548
if(plugindir != NULL){
549
errno = 0;
480
550
}
481
551
break;
482
552
case 129: /* --config-file */
483
553
/* This is already done by parse_opt_config_file() */
484
554
break;
485
555
case 130: /* --userid */
486
errno = 0;
487
tmpmax = strtoimax(arg, &tmp, 10);
556
tmp_id = strtoimax(arg, &tmp, 10);
488
557
if(errno != 0 or tmp == arg or *tmp != '\0'
489
or tmpmax != (uid_t)tmpmax){
490
fprintf(stderr, "Bad user ID number: \"%s\", using %"
491
PRIdMAX "\n", arg, (intmax_t)uid);
492
} else {
493
uid = (uid_t)tmpmax;
558
or tmp_id != (uid_t)tmp_id){
559
argp_error(state, "Bad user ID number: \"%s\", using %"
560
PRIdMAX, arg, (intmax_t)uid);
561
break;
494
562
}
563
uid = (uid_t)tmp_id;
564
errno = 0;
495
565
break;
496
566
case 131: /* --groupid */
497
errno = 0;
498
tmpmax = strtoimax(arg, &tmp, 10);
567
tmp_id = strtoimax(arg, &tmp, 10);
499
568
if(errno != 0 or tmp == arg or *tmp != '\0'
500
or tmpmax != (gid_t)tmpmax){
501
fprintf(stderr, "Bad group ID number: \"%s\", using %"
502
PRIdMAX "\n", arg, (intmax_t)gid);
503
} else {
504
gid = (gid_t)tmpmax;
569
or tmp_id != (gid_t)tmp_id){
570
argp_error(state, "Bad group ID number: \"%s\", using %"
571
PRIdMAX, arg, (intmax_t)gid);
572
break;
505
573
}
574
gid = (gid_t)tmp_id;
575
errno = 0;
506
576
break;
507
577
case 132: /* --debug */
508
578
debug = true;
509
579
break;
580
case 133: /* --plugin-helper-dir */
581
free(pluginhelperdir);
582
pluginhelperdir = strdup(arg);
583
if(pluginhelperdir != NULL){
584
errno = 0;
585
}
586
break;
587
/*
588
* These reproduce what we would get without ARGP_NO_HELP
589
*/
590
case '?': /* --help */
591
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
592
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
593
__builtin_unreachable();
594
case -3: /* --usage */
595
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
596
argp_state_help(state, state->out_stream,
597
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
598
__builtin_unreachable();
599
case 'V': /* --version */
600
fprintf(state->out_stream, "%s\n", argp_program_version);
601
exit(EXIT_SUCCESS);
602
break;
510
603
/*
511
604
* When adding more options before this line, remember to also add a
512
605
* "case" to the "parse_opt_config_file" function below.
515
608
/* Cryptsetup always passes an argument, which is an empty
516
609
string if "none" was specified in /etc/crypttab. So if
517
610
argument was empty, we ignore it silently. */
518
if(arg[0] != '\0'){
519
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
611
if(arg[0] == '\0'){
612
break;
520
613
}
521
break;
522
case ARGP_KEY_END:
523
break;
614
#if __GNUC__ >= 7
615
__attribute__((fallthrough));
616
#else
617
/* FALLTHROUGH */
618
#endif
524
619
default:
525
620
return ARGP_ERR_UNKNOWN;
526
621
}
527
return 0;
622
return errno; /* Set to 0 at start */
528
623
}
529
624
530
625
/* This option parser is the same as parse_opt() above, except it
532
627
error_t parse_opt_config_file(int key, char *arg,
533
628
__attribute__((unused))
534
629
struct argp_state *state){
630
errno = 0;
535
631
switch(key){
536
632
case 'g': /* --global-options */
537
633
case 'G': /* --global-env */
544
640
case 129: /* --config-file */
545
641
free(argfile);
546
642
argfile = strdup(arg);
547
if(argfile == NULL){
548
perror("strdup");
643
if(argfile != NULL){
644
errno = 0;
549
645
}
550
646
break;
551
647
case 130: /* --userid */
552
648
case 131: /* --groupid */
553
649
case 132: /* --debug */
650
case 133: /* --plugin-helper-dir */
651
case '?': /* --help */
652
case -3: /* --usage */
653
case 'V': /* --version */
554
654
case ARGP_KEY_ARG:
555
case ARGP_KEY_END:
556
655
break;
557
656
default:
558
657
return ARGP_ERR_UNKNOWN;
559
658
}
560
return 0;
659
return errno;
561
660
}
562
661
563
662
struct argp argp = { .options = options,
567
666
568
667
/* Parse using parse_opt_config_file() in order to get the custom
569
668
config file location, if any. */
570
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
571
if(ret == ARGP_ERR_UNKNOWN){
572
fprintf(stderr, "Unknown error while parsing arguments\n");
573
exitstatus = EXIT_FAILURE;
669
ret = argp_parse(&argp, argc, argv,
670
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
671
NULL, NULL);
672
switch(ret){
673
case 0:
674
break;
675
case ENOMEM:
676
default:
677
errno = ret;
678
error(0, errno, "argp_parse");
679
exitstatus = EX_OSERR;
680
goto fallback;
681
case EINVAL:
682
exitstatus = EX_USAGE;
574
683
goto fallback;
575
684
}
576
685
593
702
custom_argc = 1;
594
703
custom_argv = malloc(sizeof(char*) * 2);
595
704
if(custom_argv == NULL){
596
perror("malloc");
597
exitstatus = EXIT_FAILURE;
705
error(0, errno, "malloc");
706
exitstatus = EX_OSERR;
598
707
goto fallback;
599
708
}
600
709
custom_argv[0] = argv[0];
616
725
}
617
726
new_arg = strdup(p);
618
727
if(new_arg == NULL){
619
perror("strdup");
620
exitstatus = EXIT_FAILURE;
728
error(0, errno, "strdup");
729
exitstatus = EX_OSERR;
621
730
free(org_line);
622
731
goto fallback;
623
732
}
624
733
625
734
custom_argc += 1;
626
custom_argv = realloc(custom_argv, sizeof(char *)
627
* ((unsigned int) custom_argc + 1));
628
if(custom_argv == NULL){
629
perror("realloc");
630
exitstatus = EXIT_FAILURE;
631
free(org_line);
632
goto fallback;
735
{
736
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
737
char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
738
sizeof(char *));
739
#else
740
char **new_argv = NULL;
741
if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
742
/* overflow */
743
errno = ENOMEM;
744
} else {
745
new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
746
* sizeof(char *));
747
}
748
#endif
749
if(new_argv == NULL){
750
error(0, errno, "reallocarray");
751
exitstatus = EX_OSERR;
752
free(new_arg);
753
free(org_line);
754
goto fallback;
755
} else {
756
custom_argv = new_argv;
757
}
633
758
}
634
759
custom_argv[custom_argc-1] = new_arg;
635
760
custom_argv[custom_argc] = NULL;
639
764
ret = fclose(conffp);
640
765
} while(ret == EOF and errno == EINTR);
641
766
if(ret == EOF){
642
perror("fclose");
643
exitstatus = EXIT_FAILURE;
767
error(0, errno, "fclose");
768
exitstatus = EX_IOERR;
644
769
goto fallback;
645
770
}
646
771
free(org_line);
648
773
/* Check for harmful errors and go to fallback. Other errors might
649
774
not affect opening plugins */
650
775
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
651
perror("fopen");
652
exitstatus = EXIT_FAILURE;
776
error(0, errno, "fopen");
777
exitstatus = EX_OSERR;
653
778
goto fallback;
654
779
}
655
780
}
656
/* If there was any arguments from configuration file,
657
pass them to parser as command arguments */
781
/* If there were any arguments from the configuration file, pass
782
them to parser as command line arguments */
658
783
if(custom_argv != NULL){
659
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
660
0, NULL);
661
if(ret == ARGP_ERR_UNKNOWN){
662
fprintf(stderr, "Unknown error while parsing arguments\n");
663
exitstatus = EXIT_FAILURE;
784
ret = argp_parse(&argp, custom_argc, custom_argv,
785
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
786
NULL, NULL);
787
switch(ret){
788
case 0:
789
break;
790
case ENOMEM:
791
default:
792
errno = ret;
793
error(0, errno, "argp_parse");
794
exitstatus = EX_OSERR;
795
goto fallback;
796
case EINVAL:
797
exitstatus = EX_CONFIG;
664
798
goto fallback;
665
799
}
666
800
}
667
801
668
802
/* Parse actual command line arguments, to let them override the
669
803
config file */
670
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
671
if(ret == ARGP_ERR_UNKNOWN){
672
fprintf(stderr, "Unknown error while parsing arguments\n");
673
exitstatus = EXIT_FAILURE;
674
goto fallback;
804
ret = argp_parse(&argp, argc, argv,
805
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
806
NULL, NULL);
807
switch(ret){
808
case 0:
809
break;
810
case ENOMEM:
811
default:
812
errno = ret;
813
error(0, errno, "argp_parse");
814
exitstatus = EX_OSERR;
815
goto fallback;
816
case EINVAL:
817
exitstatus = EX_USAGE;
818
goto fallback;
819
}
820
821
{
822
char *pluginhelperenv;
823
bool bret = true;
824
ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
825
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
826
if(ret != -1){
827
bret = add_environment(getplugin(NULL), pluginhelperenv, true);
828
}
829
if(ret == -1 or not bret){
830
error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
831
" environment variable to \"%s\" for all plugins\n",
832
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
833
}
834
if(ret != -1){
835
free(pluginhelperenv);
836
}
675
837
}
676
838
677
839
if(debug){
678
for(plugin *p = plugin_list; p != NULL; p=p->next){
840
for(plugin *p = plugin_list; p != NULL; p = p->next){
679
841
fprintf(stderr, "Plugin: %s has %d arguments\n",
680
842
p->name ? p->name : "Global", p->argc - 1);
681
843
for(char **a = p->argv; *a != NULL; a++){
688
850
}
689
851
}
690
852
691
/* Strip permissions down to nobody */
692
setgid(gid);
853
if(getuid() == 0){
854
/* Work around Debian bug #633582:
855
<https://bugs.debian.org/633582> */
856
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
857
if(plugindir_fd == -1){
858
if(errno != ENOENT){
859
error(0, errno, "open(\"" PDIR "\")");
860
}
861
} else {
862
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
863
if(ret == -1){
864
error(0, errno, "fstat");
865
} else {
866
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
867
ret = fchown(plugindir_fd, uid, gid);
868
if(ret == -1){
869
error(0, errno, "fchown");
870
}
871
}
872
}
873
close(plugindir_fd);
874
}
875
876
/* Work around Debian bug #981302
877
<https://bugs.debian.org/981302> */
878
if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
879
ret = symlink("/proc/self/fd", "/dev/fd");
880
if(ret == -1){
881
error(0, errno, "Failed to create /dev/fd symlink");
882
}
883
}
884
}
885
886
/* Lower permissions */
887
ret = setgid(gid);
693
888
if(ret == -1){
694
perror("setgid");
889
error(0, errno, "setgid");
695
890
}
696
891
ret = setuid(uid);
697
892
if(ret == -1){
698
perror("setuid");
699
}
700
701
if(plugindir == NULL){
702
dir = opendir(PDIR);
703
} else {
704
dir = opendir(plugindir);
705
}
706
707
if(dir == NULL){
708
perror("Could not open plugin dir");
709
exitstatus = EXIT_FAILURE;
710
goto fallback;
711
}
712
713
/* Set the FD_CLOEXEC flag on the directory, if possible */
893
error(0, errno, "setuid");
894
}
895
896
/* Open plugin directory with close_on_exec flag */
714
897
{
715
int dir_fd = dirfd(dir);
716
if(dir_fd >= 0){
717
ret = set_cloexec_flag(dir_fd);
718
if(ret < 0){
719
perror("set_cloexec_flag");
720
exitstatus = EXIT_FAILURE;
721
goto fallback;
898
dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
899
#ifdef O_CLOEXEC
900
O_CLOEXEC
901
#else /* not O_CLOEXEC */
902
0
903
#endif /* not O_CLOEXEC */
904
);
905
if(dir_fd == -1){
906
error(0, errno, "Could not open plugin dir");
907
exitstatus = EX_UNAVAILABLE;
908
goto fallback;
909
}
910
911
#ifndef O_CLOEXEC
912
/* Set the FD_CLOEXEC flag on the directory */
913
ret = set_cloexec_flag(dir_fd);
914
if(ret < 0){
915
error(0, errno, "set_cloexec_flag");
916
exitstatus = EX_OSERR;
917
goto fallback;
918
}
919
#endif /* O_CLOEXEC */
920
}
921
922
int good_name(const struct dirent * const dirent){
923
const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
924
"*.dpkg-old", "*.dpkg-bak",
925
"*.dpkg-divert", NULL };
926
#ifdef __GNUC__
927
#pragma GCC diagnostic push
928
#pragma GCC diagnostic ignored "-Wcast-qual"
929
#endif
930
for(const char **pat = (const char **)patterns;
931
*pat != NULL; pat++){
932
#ifdef __GNUC__
933
#pragma GCC diagnostic pop
934
#endif
935
if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
936
!= FNM_NOMATCH){
937
if(debug){
938
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
939
" matching pattern %s\n", dirent->d_name, *pat);
940
}
941
return 0;
722
942
}
723
943
}
944
return 1;
945
}
946
947
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
948
alphasort);
949
if(numplugins == -1){
950
error(0, errno, "Could not scan plugin dir");
951
direntries = NULL;
952
exitstatus = EX_OSERR;
953
goto fallback;
724
954
}
725
955
726
956
FD_ZERO(&rfds_all);
727
957
728
958
/* Read and execute any executable in the plugin directory*/
729
while(true){
730
do {
731
dirst = readdir(dir);
732
} while(dirst == NULL and errno == EINTR);
733
734
/* All directory entries have been processed */
735
if(dirst == NULL){
736
if(errno == EBADF){
737
perror("readdir");
738
exitstatus = EXIT_FAILURE;
739
goto fallback;
740
}
741
break;
742
}
743
744
d_name_len = strlen(dirst->d_name);
745
746
/* Ignore dotfiles, backup files and other junk */
747
{
748
bool bad_name = false;
749
750
const char const *bad_prefixes[] = { ".", "#", NULL };
751
752
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
753
".dpkg-old",
754
".dpkg-bak",
755
".dpkg-divert", NULL };
756
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
757
size_t pre_len = strlen(*pre);
758
if((d_name_len >= pre_len)
759
and strncmp((dirst->d_name), *pre, pre_len) == 0){
760
if(debug){
761
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
762
" with bad prefix %s\n", dirst->d_name, *pre);
763
}
764
bad_name = true;
765
break;
766
}
767
}
768
if(bad_name){
769
continue;
770
}
771
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
772
size_t suf_len = strlen(*suf);
773
if((d_name_len >= suf_len)
774
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
775
== 0)){
776
if(debug){
777
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
778
" with bad suffix %s\n", dirst->d_name, *suf);
779
}
780
bad_name = true;
781
break;
782
}
783
}
784
785
if(bad_name){
786
continue;
787
}
788
}
789
790
char *filename;
791
if(plugindir == NULL){
792
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
793
dirst->d_name));
794
} else {
795
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
796
plugindir,
797
dirst->d_name));
798
}
799
if(ret < 0){
800
perror("asprintf");
959
for(int i = 0; i < numplugins; i++){
960
961
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
962
if(plugin_fd == -1){
963
error(0, errno, "Could not open plugin");
964
free(direntries[i]);
801
965
continue;
802
966
}
803
804
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
967
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
805
968
if(ret == -1){
806
perror("stat");
807
free(filename);
969
error(0, errno, "stat");
970
close(plugin_fd);
971
free(direntries[i]);
808
972
continue;
809
973
}
810
974
811
975
/* Ignore non-executable files */
812
976
if(not S_ISREG(st.st_mode)
813
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
977
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
978
X_OK, 0)) != 0)){
814
979
if(debug){
815
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
816
" with bad type or mode\n", filename);
980
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
981
" with bad type or mode\n",
982
plugindir != NULL ? plugindir : PDIR,
983
direntries[i]->d_name);
817
984
}
818
free(filename);
985
close(plugin_fd);
986
free(direntries[i]);
819
987
continue;
820
988
}
821
989
822
plugin *p = getplugin(dirst->d_name);
990
plugin *p = getplugin(direntries[i]->d_name);
823
991
if(p == NULL){
824
perror("getplugin");
825
free(filename);
992
error(0, errno, "getplugin");
993
close(plugin_fd);
994
free(direntries[i]);
826
995
continue;
827
996
}
828
997
if(p->disabled){
829
998
if(debug){
830
999
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
831
dirst->d_name);
1000
direntries[i]->d_name);
832
1001
}
833
free(filename);
1002
close(plugin_fd);
1003
free(direntries[i]);
834
1004
continue;
835
1005
}
836
1006
{
839
1009
if(g != NULL){
840
1010
for(char **a = g->argv + 1; *a != NULL; a++){
841
1011
if(not add_argument(p, *a)){
842
perror("add_argument");
1012
error(0, errno, "add_argument");
843
1013
}
844
1014
}
845
1015
/* Add global environment variables */
846
1016
for(char **e = g->environ; *e != NULL; e++){
847
1017
if(not add_environment(p, *e, false)){
848
perror("add_environment");
1018
error(0, errno, "add_environment");
849
1019
}
850
1020
}
851
1021
}
852
1022
}
853
/* If this plugin has any environment variables, we will call
854
using execve and need to duplicate the environment from this
855
process, too. */
1023
/* If this plugin has any environment variables, we need to
1024
duplicate the environment from this process, too. */
856
1025
if(p->environ[0] != NULL){
857
1026
for(char **e = environ; *e != NULL; e++){
858
1027
if(not add_environment(p, *e, false)){
859
perror("add_environment");
1028
error(0, errno, "add_environment");
860
1029
}
861
1030
}
862
1031
}
863
1032
864
1033
int pipefd[2];
1034
#ifndef O_CLOEXEC
865
1035
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
1036
#else /* O_CLOEXEC */
1037
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
1038
#endif /* O_CLOEXEC */
866
1039
if(ret == -1){
867
perror("pipe");
868
exitstatus = EXIT_FAILURE;
869
goto fallback;
870
}
1040
error(0, errno, "pipe");
1041
exitstatus = EX_OSERR;
1042
free(direntries[i]);
1043
goto fallback;
1044
}
1045
if(pipefd[0] >= FD_SETSIZE){
1046
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1047
FD_SETSIZE);
1048
close(pipefd[0]);
1049
close(pipefd[1]);
1050
exitstatus = EX_OSERR;
1051
free(direntries[i]);
1052
goto fallback;
1053
}
1054
#ifndef O_CLOEXEC
871
1055
/* Ask OS to automatic close the pipe on exec */
872
1056
ret = set_cloexec_flag(pipefd[0]);
873
1057
if(ret < 0){
874
perror("set_cloexec_flag");
875
exitstatus = EXIT_FAILURE;
1058
error(0, errno, "set_cloexec_flag");
1059
close(pipefd[0]);
1060
close(pipefd[1]);
1061
exitstatus = EX_OSERR;
1062
free(direntries[i]);
876
1063
goto fallback;
877
1064
}
878
1065
ret = set_cloexec_flag(pipefd[1]);
879
1066
if(ret < 0){
880
perror("set_cloexec_flag");
881
exitstatus = EXIT_FAILURE;
1067
error(0, errno, "set_cloexec_flag");
1068
close(pipefd[0]);
1069
close(pipefd[1]);
1070
exitstatus = EX_OSERR;
1071
free(direntries[i]);
882
1072
goto fallback;
883
1073
}
1074
#endif /* not O_CLOEXEC */
884
1075
/* Block SIGCHLD until process is safely in process list */
885
1076
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
886
1077
&sigchld_action.sa_mask,
887
1078
NULL));
888
1079
if(ret < 0){
889
perror("sigprocmask");
890
exitstatus = EXIT_FAILURE;
1080
error(0, errno, "sigprocmask");
1081
exitstatus = EX_OSERR;
1082
free(direntries[i]);
891
1083
goto fallback;
892
1084
}
893
1085
/* Starting a new process to be watched */
896
1088
pid = fork();
897
1089
} while(pid == -1 and errno == EINTR);
898
1090
if(pid == -1){
899
perror("fork");
900
exitstatus = EXIT_FAILURE;
1091
error(0, errno, "fork");
1092
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1093
&sigchld_action.sa_mask, NULL));
1094
close(pipefd[0]);
1095
close(pipefd[1]);
1096
exitstatus = EX_OSERR;
1097
free(direntries[i]);
901
1098
goto fallback;
902
1099
}
903
1100
if(pid == 0){
904
1101
/* this is the child process */
905
1102
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
906
1103
if(ret < 0){
907
perror("sigaction");
908
_exit(EXIT_FAILURE);
1104
error(0, errno, "sigaction");
1105
_exit(EX_OSERR);
909
1106
}
910
1107
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
911
1108
if(ret < 0){
912
perror("sigprocmask");
913
_exit(EXIT_FAILURE);
1109
error(0, errno, "sigprocmask");
1110
_exit(EX_OSERR);
914
1111
}
915
1112
916
1113
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
917
1114
if(ret == -1){
918
perror("dup2");
919
_exit(EXIT_FAILURE);
1115
error(0, errno, "dup2");
1116
_exit(EX_OSERR);
920
1117
}
921
1118
922
if(dirfd(dir) < 0){
923
/* If dir has no file descriptor, we could not set FD_CLOEXEC
924
above and must now close it manually here. */
925
closedir(dir);
926
}
927
if(p->environ[0] == NULL){
928
if(execv(filename, p->argv) < 0){
929
perror("execv");
930
_exit(EXIT_FAILURE);
931
}
932
} else {
933
if(execve(filename, p->argv, p->environ) < 0){
934
perror("execve");
935
_exit(EXIT_FAILURE);
936
}
1119
if(fexecve(plugin_fd, p->argv,
1120
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1121
error(0, errno, "fexecve for %s/%s",
1122
plugindir != NULL ? plugindir : PDIR,
1123
direntries[i]->d_name);
1124
_exit(EX_OSERR);
937
1125
}
938
1126
/* no return */
939
1127
}
940
1128
/* Parent process */
941
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
942
pipe */
943
free(filename);
944
plugin *new_plugin = getplugin(dirst->d_name);
1129
close(pipefd[1]); /* Close unused write end of pipe */
1130
close(plugin_fd);
1131
plugin *new_plugin = getplugin(direntries[i]->d_name);
945
1132
if(new_plugin == NULL){
946
perror("getplugin");
1133
error(0, errno, "getplugin");
947
1134
ret = (int)(TEMP_FAILURE_RETRY
948
1135
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
949
1136
NULL)));
950
1137
if(ret < 0){
951
perror("sigprocmask");
1138
error(0, errno, "sigprocmask");
952
1139
}
953
exitstatus = EXIT_FAILURE;
1140
exitstatus = EX_OSERR;
1141
free(direntries[i]);
954
1142
goto fallback;
955
1143
}
1144
free(direntries[i]);
956
1145
957
1146
new_plugin->pid = pid;
958
1147
new_plugin->fd = pipefd[0];
959
1148
1149
if(debug){
1150
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1151
new_plugin->name, (intmax_t) (new_plugin->pid));
1152
}
1153
960
1154
/* Unblock SIGCHLD so signal handler can be run if this process
961
1155
has already completed */
962
1156
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
963
1157
&sigchld_action.sa_mask,
964
1158
NULL));
965
1159
if(ret < 0){
966
perror("sigprocmask");
967
exitstatus = EXIT_FAILURE;
1160
error(0, errno, "sigprocmask");
1161
exitstatus = EX_OSERR;
968
1162
goto fallback;
969
1163
}
970
1164
975
1169
}
976
1170
}
977
1171
978
TEMP_FAILURE_RETRY(closedir(dir));
979
dir = NULL;
1172
free(direntries);
1173
direntries = NULL;
1174
close(dir_fd);
1175
dir_fd = -1;
980
1176
free_plugin(getplugin(NULL));
981
1177
982
1178
for(plugin *p = plugin_list; p != NULL; p = p->next){
995
1191
fd_set rfds = rfds_all;
996
1192
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
997
1193
if(select_ret == -1 and errno != EINTR){
998
perror("select");
999
exitstatus = EXIT_FAILURE;
1194
error(0, errno, "select");
1195
exitstatus = EX_OSERR;
1000
1196
goto fallback;
1001
1197
}
1002
1198
/* OK, now either a process completed, or something can be read
1021
1217
(intmax_t) (proc->pid),
1022
1218
WTERMSIG(proc->status),
1023
1219
strsignal(WTERMSIG(proc->status)));
1024
} else if(WCOREDUMP(proc->status)){
1025
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1026
" core\n", proc->name, (intmax_t) (proc->pid));
1027
1220
}
1028
1221
}
1029
1222
1036
1229
&sigchld_action.sa_mask,
1037
1230
NULL));
1038
1231
if(ret < 0){
1039
perror("sigprocmask");
1040
exitstatus = EXIT_FAILURE;
1232
error(0, errno, "sigprocmask");
1233
exitstatus = EX_OSERR;
1041
1234
goto fallback;
1042
1235
}
1043
1236
1050
1243
(sigprocmask(SIG_UNBLOCK,
1051
1244
&sigchld_action.sa_mask, NULL)));
1052
1245
if(ret < 0){
1053
perror("sigprocmask");
1054
exitstatus = EXIT_FAILURE;
1246
error(0, errno, "sigprocmask");
1247
exitstatus = EX_OSERR;
1055
1248
goto fallback;
1056
1249
}
1057
1250
1067
1260
bool bret = print_out_password(proc->buffer,
1068
1261
proc->buffer_length);
1069
1262
if(not bret){
1070
perror("print_out_password");
1071
exitstatus = EXIT_FAILURE;
1263
error(0, errno, "print_out_password");
1264
exitstatus = EX_IOERR;
1072
1265
}
1073
1266
goto fallback;
1074
1267
}
1081
1274
}
1082
1275
/* Before reading, make the process' data buffer large enough */
1083
1276
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1084
proc->buffer = realloc(proc->buffer, proc->buffer_size
1085
+ (size_t) BUFFER_SIZE);
1086
if(proc->buffer == NULL){
1087
perror("malloc");
1088
exitstatus = EXIT_FAILURE;
1277
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1278
+ (size_t) BUFFER_SIZE);
1279
if(new_buffer == NULL){
1280
error(0, errno, "malloc");
1281
exitstatus = EX_OSERR;
1089
1282
goto fallback;
1090
1283
}
1284
proc->buffer = new_buffer;
1091
1285
proc->buffer_size += BUFFER_SIZE;
1092
1286
}
1093
1287
/* Read from the process */
1112
1306
1113
1307
fallback:
1114
1308
1115
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1309
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1310
and exitstatus != EX_OK)){
1116
1311
/* Fallback if all plugins failed, none are found or an error
1117
1312
occured */
1118
1313
bool bret;
1126
1321
}
1127
1322
bret = print_out_password(passwordbuffer, len);
1128
1323
if(not bret){
1129
perror("print_out_password");
1130
exitstatus = EXIT_FAILURE;
1324
error(0, errno, "print_out_password");
1325
exitstatus = EX_IOERR;
1131
1326
}
1132
1327
}
1133
1328
1134
1329
/* Restore old signal handler */
1135
1330
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1136
1331
if(ret == -1){
1137
perror("sigaction");
1138
exitstatus = EXIT_FAILURE;
1332
error(0, errno, "sigaction");
1333
exitstatus = EX_OSERR;
1139
1334
}
1140
1335
1141
1336
if(custom_argv != NULL){
1145
1340
free(custom_argv);
1146
1341
}
1147
1342
1148
if(dir != NULL){
1149
closedir(dir);
1343
free(direntries);
1344
1345
if(dir_fd != -1){
1346
close(dir_fd);
1150
1347
}
1151
1348
1152
1349
/* Kill the processes */
1156
1353
ret = kill(p->pid, SIGTERM);
1157
1354
if(ret == -1 and errno != ESRCH){
1158
1355
/* Set-uid proccesses might not get closed */
1159
perror("kill");
1356
error(0, errno, "kill");
1160
1357
}
1161
1358
}
1162
1359
}
1166
1363
ret = wait(NULL);
1167
1364
} while(ret >= 0);
1168
1365
if(errno != ECHILD){
1169
perror("wait");
1366
error(0, errno, "wait");
1170
1367
}
1171
1368
1172
1369
free_plugin_list();
1173
1370
1174
1371
free(plugindir);
1372
free(pluginhelperdir);
1175
1373
free(argfile);
1176
1374
1177
1375
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0