To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugin-runner.c
- browse files at revision 237.7.785
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.785
- Committer: Teddy Hogeborn
- Date: 2021-02-03 23:10:42 UTC
- mto: This revision was merged to the branch mainline in revision 406.
- 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(), O_CLOEXEC */
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, fdopendir(), 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, fdopendir(),
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() */
71
#include <sysexits.h> /* EX_OSERR, EX_USAGE */
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 */
72
89
73
90
#define BUFFER_SIZE 256
74
91
75
92
#define PDIR "/lib/mandos/plugins.d"
93
#define PHDIR "/lib/mandos/plugin-helpers"
76
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
77
95
78
96
const char *argp_program_version = "plugin-runner " VERSION;
79
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
80
98
81
99
typedef struct plugin{
82
100
char *name; /* can be NULL or any plugin name */
102
120
103
121
/* Gets an existing plugin based on name,
104
122
or if none is found, creates a new one */
123
__attribute__((warn_unused_result))
105
124
static plugin *getplugin(char *name){
106
125
/* Check for existing plugin with that name */
107
126
for(plugin *p = plugin_list; p != NULL; p = p->next){
168
187
}
169
188
170
189
/* Helper function for add_argument and add_environment */
190
__attribute__((nonnull, warn_unused_result))
171
191
static bool add_to_char_array(const char *new, char ***array,
172
192
int *len){
173
193
/* Resize the pointed-to array to hold one more pointer */
194
char **new_array = NULL;
174
195
do {
175
*array = realloc(*array, sizeof(char *)
176
* (size_t) ((*len) + 2));
177
} 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);
178
210
/* Malloc check */
179
if(*array == NULL){
211
if(new_array == NULL){
180
212
return false;
181
213
}
214
*array = new_array;
182
215
/* Make a copy of the new string */
183
216
char *copy;
184
217
do {
196
229
}
197
230
198
231
/* Add to a plugin's argument vector */
232
__attribute__((nonnull(2), warn_unused_result))
199
233
static bool add_argument(plugin *p, const char *arg){
200
234
if(p == NULL){
201
235
return false;
204
238
}
205
239
206
240
/* Add to a plugin's environment */
241
__attribute__((nonnull(2), warn_unused_result))
207
242
static bool add_environment(plugin *p, const char *def, bool replace){
208
243
if(p == NULL){
209
244
return false;
211
246
/* namelen = length of name of environment variable */
212
247
size_t namelen = (size_t)(strchrnul(def, '=') - def);
213
248
/* Search for this environment variable */
214
for(char **e = p->environ; *e != NULL; e++){
215
if(strncmp(*e, def, namelen + 1) == 0){
249
for(char **envdef = p->environ; *envdef != NULL; envdef++){
250
if(strncmp(*envdef, def, namelen + 1) == 0){
216
251
/* It already exists */
217
252
if(replace){
218
char *new;
253
char *new_envdef;
219
254
do {
220
new = realloc(*e, strlen(def) + 1);
221
} while(new == NULL and errno == EINTR);
222
if(new == NULL){
255
new_envdef = realloc(*envdef, strlen(def) + 1);
256
} while(new_envdef == NULL and errno == EINTR);
257
if(new_envdef == NULL){
223
258
return false;
224
259
}
225
*e = new;
226
strcpy(*e, def);
260
*envdef = new_envdef;
261
strcpy(*envdef, def);
227
262
}
228
263
return true;
229
264
}
231
266
return add_to_char_array(def, &(p->environ), &(p->envc));
232
267
}
233
268
269
#ifndef O_CLOEXEC
234
270
/*
235
271
* Based on the example in the GNU LibC manual chapter 13.13 "File
236
272
* Descriptor Flags".
237
273
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
238
274
*/
275
__attribute__((warn_unused_result))
239
276
static int set_cloexec_flag(int fd){
240
277
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
241
278
/* If reading the flags failed, return error indication now. */
246
283
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
247
284
ret | FD_CLOEXEC));
248
285
}
286
#endif /* not O_CLOEXEC */
249
287
250
288
251
289
/* Mark processes as completed when they exit, and save their exit
265
303
/* No child processes */
266
304
break;
267
305
}
268
perror("waitpid");
306
error(0, errno, "waitpid");
269
307
}
270
308
271
309
/* A child exited, find it in process_list */
283
321
}
284
322
285
323
/* Prints out a password to stdout */
324
__attribute__((nonnull, warn_unused_result))
286
325
static bool print_out_password(const char *buffer, size_t length){
287
326
ssize_t ret;
288
327
for(size_t written = 0; written < length; written += (size_t)ret){
296
335
}
297
336
298
337
/* Removes and free a plugin from the plugin list */
338
__attribute__((nonnull))
299
339
static void free_plugin(plugin *plugin_node){
300
340
301
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
341
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
302
342
free(*arg);
303
343
}
344
free(plugin_node->name);
304
345
free(plugin_node->argv);
305
346
for(char **env = plugin_node->environ; *env != NULL; env++){
306
347
free(*env);
333
374
334
375
int main(int argc, char *argv[]){
335
376
char *plugindir = NULL;
377
char *pluginhelperdir = NULL;
336
378
char *argfile = NULL;
337
379
FILE *conffp;
338
size_t d_name_len;
339
DIR *dir = NULL;
340
struct dirent *dirst;
380
struct dirent **direntries = NULL;
341
381
struct stat st;
342
382
fd_set rfds_all;
343
383
int ret, maxfd = 0;
351
391
.sa_flags = SA_NOCLDSTOP };
352
392
char **custom_argv = NULL;
353
393
int custom_argc = 0;
394
int dir_fd = -1;
354
395
355
396
/* Establish a signal handler */
356
397
sigemptyset(&sigchld_action.sa_mask);
357
398
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
358
399
if(ret == -1){
359
perror("sigaddset");
360
exitstatus = EXIT_FAILURE;
400
error(0, errno, "sigaddset");
401
exitstatus = EX_OSERR;
361
402
goto fallback;
362
403
}
363
404
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
364
405
if(ret == -1){
365
perror("sigaction");
366
exitstatus = EXIT_FAILURE;
406
error(0, errno, "sigaction");
407
exitstatus = EX_OSERR;
367
408
goto fallback;
368
409
}
369
410
401
442
.doc = "Group ID the plugins will run as", .group = 3 },
402
443
{ .name = "debug", .key = 132,
403
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 },
404
449
/*
405
450
* These reproduce what we would get without ARGP_NO_HELP
406
451
*/
413
458
{ .name = NULL }
414
459
};
415
460
461
__attribute__((nonnull(3)))
416
462
error_t parse_opt(int key, char *arg, struct argp_state *state){
417
463
errno = 0;
418
464
switch(key){
419
465
char *tmp;
420
intmax_t tmpmax;
466
intmax_t tmp_id;
421
467
case 'g': /* --global-options */
422
468
{
423
469
char *plugin_option;
426
472
break;
427
473
}
428
474
}
475
errno = 0;
429
476
}
430
477
break;
431
478
case 'G': /* --global-env */
432
add_environment(getplugin(NULL), arg, true);
479
if(add_environment(getplugin(NULL), arg, true)){
480
errno = 0;
481
}
433
482
break;
434
483
case 'o': /* --options-for */
435
484
{
452
501
break;
453
502
}
454
503
}
504
errno = 0;
455
505
}
456
506
break;
457
507
case 'E': /* --env-for */
469
519
errno = EINVAL;
470
520
break;
471
521
}
472
add_environment(getplugin(arg), envdef, true);
522
if(add_environment(getplugin(arg), envdef, true)){
523
errno = 0;
524
}
473
525
}
474
526
break;
475
527
case 'd': /* --disable */
477
529
plugin *p = getplugin(arg);
478
530
if(p != NULL){
479
531
p->disabled = true;
532
errno = 0;
480
533
}
481
534
}
482
535
break;
485
538
plugin *p = getplugin(arg);
486
539
if(p != NULL){
487
540
p->disabled = false;
541
errno = 0;
488
542
}
489
543
}
490
544
break;
491
545
case 128: /* --plugin-dir */
492
546
free(plugindir);
493
547
plugindir = strdup(arg);
548
if(plugindir != NULL){
549
errno = 0;
550
}
494
551
break;
495
552
case 129: /* --config-file */
496
553
/* This is already done by parse_opt_config_file() */
497
554
break;
498
555
case 130: /* --userid */
499
tmpmax = strtoimax(arg, &tmp, 10);
556
tmp_id = strtoimax(arg, &tmp, 10);
500
557
if(errno != 0 or tmp == arg or *tmp != '\0'
501
or tmpmax != (uid_t)tmpmax){
558
or tmp_id != (uid_t)tmp_id){
502
559
argp_error(state, "Bad user ID number: \"%s\", using %"
503
560
PRIdMAX, arg, (intmax_t)uid);
504
561
break;
505
562
}
506
uid = (uid_t)tmpmax;
563
uid = (uid_t)tmp_id;
564
errno = 0;
507
565
break;
508
566
case 131: /* --groupid */
509
tmpmax = strtoimax(arg, &tmp, 10);
567
tmp_id = strtoimax(arg, &tmp, 10);
510
568
if(errno != 0 or tmp == arg or *tmp != '\0'
511
or tmpmax != (gid_t)tmpmax){
569
or tmp_id != (gid_t)tmp_id){
512
570
argp_error(state, "Bad group ID number: \"%s\", using %"
513
571
PRIdMAX, arg, (intmax_t)gid);
514
572
break;
515
573
}
516
gid = (gid_t)tmpmax;
574
gid = (gid_t)tmp_id;
575
errno = 0;
517
576
break;
518
577
case 132: /* --debug */
519
578
debug = true;
520
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;
521
587
/*
522
588
* These reproduce what we would get without ARGP_NO_HELP
523
589
*/
524
590
case '?': /* --help */
525
591
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
526
592
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
593
__builtin_unreachable();
527
594
case -3: /* --usage */
528
595
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
529
596
argp_state_help(state, state->out_stream,
530
597
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
598
__builtin_unreachable();
531
599
case 'V': /* --version */
532
600
fprintf(state->out_stream, "%s\n", argp_program_version);
533
601
exit(EXIT_SUCCESS);
543
611
if(arg[0] == '\0'){
544
612
break;
545
613
}
614
#if __GNUC__ >= 7
615
__attribute__((fallthrough));
616
#else
617
/* FALLTHROUGH */
618
#endif
546
619
default:
547
620
return ARGP_ERR_UNKNOWN;
548
621
}
567
640
case 129: /* --config-file */
568
641
free(argfile);
569
642
argfile = strdup(arg);
643
if(argfile != NULL){
644
errno = 0;
645
}
570
646
break;
571
647
case 130: /* --userid */
572
648
case 131: /* --groupid */
573
649
case 132: /* --debug */
650
case 133: /* --plugin-helper-dir */
574
651
case '?': /* --help */
575
652
case -3: /* --usage */
576
653
case 'V': /* --version */
598
675
case ENOMEM:
599
676
default:
600
677
errno = ret;
601
perror("argp_parse");
678
error(0, errno, "argp_parse");
602
679
exitstatus = EX_OSERR;
603
680
goto fallback;
604
681
case EINVAL:
625
702
custom_argc = 1;
626
703
custom_argv = malloc(sizeof(char*) * 2);
627
704
if(custom_argv == NULL){
628
perror("malloc");
629
exitstatus = EXIT_FAILURE;
705
error(0, errno, "malloc");
706
exitstatus = EX_OSERR;
630
707
goto fallback;
631
708
}
632
709
custom_argv[0] = argv[0];
648
725
}
649
726
new_arg = strdup(p);
650
727
if(new_arg == NULL){
651
perror("strdup");
652
exitstatus = EXIT_FAILURE;
728
error(0, errno, "strdup");
729
exitstatus = EX_OSERR;
653
730
free(org_line);
654
731
goto fallback;
655
732
}
656
733
657
734
custom_argc += 1;
658
custom_argv = realloc(custom_argv, sizeof(char *)
659
* ((unsigned int) custom_argc + 1));
660
if(custom_argv == NULL){
661
perror("realloc");
662
exitstatus = EXIT_FAILURE;
663
free(org_line);
664
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
}
665
758
}
666
759
custom_argv[custom_argc-1] = new_arg;
667
760
custom_argv[custom_argc] = NULL;
671
764
ret = fclose(conffp);
672
765
} while(ret == EOF and errno == EINTR);
673
766
if(ret == EOF){
674
perror("fclose");
675
exitstatus = EXIT_FAILURE;
767
error(0, errno, "fclose");
768
exitstatus = EX_IOERR;
676
769
goto fallback;
677
770
}
678
771
free(org_line);
680
773
/* Check for harmful errors and go to fallback. Other errors might
681
774
not affect opening plugins */
682
775
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
683
perror("fopen");
684
exitstatus = EXIT_FAILURE;
776
error(0, errno, "fopen");
777
exitstatus = EX_OSERR;
685
778
goto fallback;
686
779
}
687
780
}
697
790
case ENOMEM:
698
791
default:
699
792
errno = ret;
700
perror("argp_parse");
793
error(0, errno, "argp_parse");
701
794
exitstatus = EX_OSERR;
702
795
goto fallback;
703
796
case EINVAL:
717
810
case ENOMEM:
718
811
default:
719
812
errno = ret;
720
perror("argp_parse");
813
error(0, errno, "argp_parse");
721
814
exitstatus = EX_OSERR;
722
815
goto fallback;
723
816
case EINVAL:
725
818
goto fallback;
726
819
}
727
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
}
837
}
838
728
839
if(debug){
729
for(plugin *p = plugin_list; p != NULL; p=p->next){
840
for(plugin *p = plugin_list; p != NULL; p = p->next){
730
841
fprintf(stderr, "Plugin: %s has %d arguments\n",
731
842
p->name ? p->name : "Global", p->argc - 1);
732
843
for(char **a = p->argv; *a != NULL; a++){
739
850
}
740
851
}
741
852
742
/* Strip permissions down to nobody */
743
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);
744
888
if(ret == -1){
745
perror("setgid");
889
error(0, errno, "setgid");
746
890
}
747
891
ret = setuid(uid);
748
892
if(ret == -1){
749
perror("setuid");
893
error(0, errno, "setuid");
750
894
}
751
895
752
896
/* Open plugin directory with close_on_exec flag */
753
897
{
754
int dir_fd = -1;
755
if(plugindir == NULL){
756
dir_fd = open(PDIR, O_RDONLY |
757
#ifdef O_CLOEXEC
758
O_CLOEXEC
759
#else /* not O_CLOEXEC */
760
0
761
#endif /* not O_CLOEXEC */
762
);
763
} else {
764
dir_fd = open(plugindir, O_RDONLY |
765
#ifdef O_CLOEXEC
766
O_CLOEXEC
767
#else /* not O_CLOEXEC */
768
0
769
#endif /* not O_CLOEXEC */
770
);
771
}
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
);
772
905
if(dir_fd == -1){
773
perror("Could not open plugin dir");
774
exitstatus = EXIT_FAILURE;
906
error(0, errno, "Could not open plugin dir");
907
exitstatus = EX_UNAVAILABLE;
775
908
goto fallback;
776
909
}
777
910
779
912
/* Set the FD_CLOEXEC flag on the directory */
780
913
ret = set_cloexec_flag(dir_fd);
781
914
if(ret < 0){
782
perror("set_cloexec_flag");
783
TEMP_FAILURE_RETRY(close(dir_fd));
784
exitstatus = EXIT_FAILURE;
915
error(0, errno, "set_cloexec_flag");
916
exitstatus = EX_OSERR;
785
917
goto fallback;
786
918
}
787
919
#endif /* O_CLOEXEC */
788
789
dir = fdopendir(dir_fd);
790
if(dir == NULL){
791
perror("Could not open plugin dir");
792
TEMP_FAILURE_RETRY(close(dir_fd));
793
exitstatus = EXIT_FAILURE;
794
goto fallback;
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;
942
}
795
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;
796
954
}
797
955
798
956
FD_ZERO(&rfds_all);
799
957
800
958
/* Read and execute any executable in the plugin directory*/
801
while(true){
802
do {
803
dirst = readdir(dir);
804
} while(dirst == NULL and errno == EINTR);
805
806
/* All directory entries have been processed */
807
if(dirst == NULL){
808
if(errno == EBADF){
809
perror("readdir");
810
exitstatus = EXIT_FAILURE;
811
goto fallback;
812
}
813
break;
814
}
815
816
d_name_len = strlen(dirst->d_name);
817
818
/* Ignore dotfiles, backup files and other junk */
819
{
820
bool bad_name = false;
821
822
const char const *bad_prefixes[] = { ".", "#", NULL };
823
824
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
825
".dpkg-old",
826
".dpkg-bak",
827
".dpkg-divert", NULL };
828
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
829
size_t pre_len = strlen(*pre);
830
if((d_name_len >= pre_len)
831
and strncmp((dirst->d_name), *pre, pre_len) == 0){
832
if(debug){
833
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
834
" with bad prefix %s\n", dirst->d_name, *pre);
835
}
836
bad_name = true;
837
break;
838
}
839
}
840
if(bad_name){
841
continue;
842
}
843
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
844
size_t suf_len = strlen(*suf);
845
if((d_name_len >= suf_len)
846
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
847
== 0)){
848
if(debug){
849
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
850
" with bad suffix %s\n", dirst->d_name, *suf);
851
}
852
bad_name = true;
853
break;
854
}
855
}
856
857
if(bad_name){
858
continue;
859
}
860
}
861
862
char *filename;
863
if(plugindir == NULL){
864
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
865
dirst->d_name));
866
} else {
867
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
868
plugindir,
869
dirst->d_name));
870
}
871
if(ret < 0){
872
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]);
873
965
continue;
874
966
}
875
876
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
967
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
877
968
if(ret == -1){
878
perror("stat");
879
free(filename);
969
error(0, errno, "stat");
970
close(plugin_fd);
971
free(direntries[i]);
880
972
continue;
881
973
}
882
974
883
975
/* Ignore non-executable files */
884
976
if(not S_ISREG(st.st_mode)
885
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)){
886
979
if(debug){
887
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
888
" 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);
889
984
}
890
free(filename);
985
close(plugin_fd);
986
free(direntries[i]);
891
987
continue;
892
988
}
893
989
894
plugin *p = getplugin(dirst->d_name);
990
plugin *p = getplugin(direntries[i]->d_name);
895
991
if(p == NULL){
896
perror("getplugin");
897
free(filename);
992
error(0, errno, "getplugin");
993
close(plugin_fd);
994
free(direntries[i]);
898
995
continue;
899
996
}
900
997
if(p->disabled){
901
998
if(debug){
902
999
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
903
dirst->d_name);
1000
direntries[i]->d_name);
904
1001
}
905
free(filename);
1002
close(plugin_fd);
1003
free(direntries[i]);
906
1004
continue;
907
1005
}
908
1006
{
911
1009
if(g != NULL){
912
1010
for(char **a = g->argv + 1; *a != NULL; a++){
913
1011
if(not add_argument(p, *a)){
914
perror("add_argument");
1012
error(0, errno, "add_argument");
915
1013
}
916
1014
}
917
1015
/* Add global environment variables */
918
1016
for(char **e = g->environ; *e != NULL; e++){
919
1017
if(not add_environment(p, *e, false)){
920
perror("add_environment");
1018
error(0, errno, "add_environment");
921
1019
}
922
1020
}
923
1021
}
924
1022
}
925
/* If this plugin has any environment variables, we will call
926
using execve and need to duplicate the environment from this
927
process, too. */
1023
/* If this plugin has any environment variables, we need to
1024
duplicate the environment from this process, too. */
928
1025
if(p->environ[0] != NULL){
929
1026
for(char **e = environ; *e != NULL; e++){
930
1027
if(not add_environment(p, *e, false)){
931
perror("add_environment");
1028
error(0, errno, "add_environment");
932
1029
}
933
1030
}
934
1031
}
935
1032
936
1033
int pipefd[2];
1034
#ifndef O_CLOEXEC
937
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 */
938
1039
if(ret == -1){
939
perror("pipe");
940
exitstatus = EXIT_FAILURE;
941
goto fallback;
942
}
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
943
1055
/* Ask OS to automatic close the pipe on exec */
944
1056
ret = set_cloexec_flag(pipefd[0]);
945
1057
if(ret < 0){
946
perror("set_cloexec_flag");
947
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]);
948
1063
goto fallback;
949
1064
}
950
1065
ret = set_cloexec_flag(pipefd[1]);
951
1066
if(ret < 0){
952
perror("set_cloexec_flag");
953
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]);
954
1072
goto fallback;
955
1073
}
1074
#endif /* not O_CLOEXEC */
956
1075
/* Block SIGCHLD until process is safely in process list */
957
1076
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
958
1077
&sigchld_action.sa_mask,
959
1078
NULL));
960
1079
if(ret < 0){
961
perror("sigprocmask");
962
exitstatus = EXIT_FAILURE;
1080
error(0, errno, "sigprocmask");
1081
exitstatus = EX_OSERR;
1082
free(direntries[i]);
963
1083
goto fallback;
964
1084
}
965
1085
/* Starting a new process to be watched */
968
1088
pid = fork();
969
1089
} while(pid == -1 and errno == EINTR);
970
1090
if(pid == -1){
971
perror("fork");
972
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]);
973
1098
goto fallback;
974
1099
}
975
1100
if(pid == 0){
976
1101
/* this is the child process */
977
1102
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
978
1103
if(ret < 0){
979
perror("sigaction");
980
_exit(EXIT_FAILURE);
1104
error(0, errno, "sigaction");
1105
_exit(EX_OSERR);
981
1106
}
982
1107
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
983
1108
if(ret < 0){
984
perror("sigprocmask");
985
_exit(EXIT_FAILURE);
1109
error(0, errno, "sigprocmask");
1110
_exit(EX_OSERR);
986
1111
}
987
1112
988
1113
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
989
1114
if(ret == -1){
990
perror("dup2");
991
_exit(EXIT_FAILURE);
1115
error(0, errno, "dup2");
1116
_exit(EX_OSERR);
992
1117
}
993
1118
994
if(dirfd(dir) < 0){
995
/* If dir has no file descriptor, we could not set FD_CLOEXEC
996
above and must now close it manually here. */
997
closedir(dir);
998
}
999
if(p->environ[0] == NULL){
1000
if(execv(filename, p->argv) < 0){
1001
perror("execv");
1002
_exit(EXIT_FAILURE);
1003
}
1004
} else {
1005
if(execve(filename, p->argv, p->environ) < 0){
1006
perror("execve");
1007
_exit(EXIT_FAILURE);
1008
}
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);
1009
1125
}
1010
1126
/* no return */
1011
1127
}
1012
1128
/* Parent process */
1013
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1014
pipe */
1015
free(filename);
1016
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);
1017
1132
if(new_plugin == NULL){
1018
perror("getplugin");
1133
error(0, errno, "getplugin");
1019
1134
ret = (int)(TEMP_FAILURE_RETRY
1020
1135
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1021
1136
NULL)));
1022
1137
if(ret < 0){
1023
perror("sigprocmask");
1138
error(0, errno, "sigprocmask");
1024
1139
}
1025
exitstatus = EXIT_FAILURE;
1140
exitstatus = EX_OSERR;
1141
free(direntries[i]);
1026
1142
goto fallback;
1027
1143
}
1144
free(direntries[i]);
1028
1145
1029
1146
new_plugin->pid = pid;
1030
1147
new_plugin->fd = pipefd[0];
1031
1148
1149
if(debug){
1150
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1151
new_plugin->name, (intmax_t) (new_plugin->pid));
1152
}
1153
1032
1154
/* Unblock SIGCHLD so signal handler can be run if this process
1033
1155
has already completed */
1034
1156
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1035
1157
&sigchld_action.sa_mask,
1036
1158
NULL));
1037
1159
if(ret < 0){
1038
perror("sigprocmask");
1039
exitstatus = EXIT_FAILURE;
1160
error(0, errno, "sigprocmask");
1161
exitstatus = EX_OSERR;
1040
1162
goto fallback;
1041
1163
}
1042
1164
1043
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1044
-Wconversion */
1165
FD_SET(new_plugin->fd, &rfds_all);
1045
1166
1046
1167
if(maxfd < new_plugin->fd){
1047
1168
maxfd = new_plugin->fd;
1048
1169
}
1049
1170
}
1050
1171
1051
TEMP_FAILURE_RETRY(closedir(dir));
1052
dir = NULL;
1172
free(direntries);
1173
direntries = NULL;
1174
close(dir_fd);
1175
dir_fd = -1;
1053
1176
free_plugin(getplugin(NULL));
1054
1177
1055
1178
for(plugin *p = plugin_list; p != NULL; p = p->next){
1068
1191
fd_set rfds = rfds_all;
1069
1192
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1070
1193
if(select_ret == -1 and errno != EINTR){
1071
perror("select");
1072
exitstatus = EXIT_FAILURE;
1194
error(0, errno, "select");
1195
exitstatus = EX_OSERR;
1073
1196
goto fallback;
1074
1197
}
1075
1198
/* OK, now either a process completed, or something can be read
1094
1217
(intmax_t) (proc->pid),
1095
1218
WTERMSIG(proc->status),
1096
1219
strsignal(WTERMSIG(proc->status)));
1097
} else if(WCOREDUMP(proc->status)){
1098
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1099
" core\n", proc->name, (intmax_t) (proc->pid));
1100
1220
}
1101
1221
}
1102
1222
1103
1223
/* Remove the plugin */
1104
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1105
-Wconversion */
1224
FD_CLR(proc->fd, &rfds_all);
1106
1225
1107
1226
/* Block signal while modifying process_list */
1108
1227
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1110
1229
&sigchld_action.sa_mask,
1111
1230
NULL));
1112
1231
if(ret < 0){
1113
perror("sigprocmask");
1114
exitstatus = EXIT_FAILURE;
1232
error(0, errno, "sigprocmask");
1233
exitstatus = EX_OSERR;
1115
1234
goto fallback;
1116
1235
}
1117
1236
1124
1243
(sigprocmask(SIG_UNBLOCK,
1125
1244
&sigchld_action.sa_mask, NULL)));
1126
1245
if(ret < 0){
1127
perror("sigprocmask");
1128
exitstatus = EXIT_FAILURE;
1246
error(0, errno, "sigprocmask");
1247
exitstatus = EX_OSERR;
1129
1248
goto fallback;
1130
1249
}
1131
1250
1141
1260
bool bret = print_out_password(proc->buffer,
1142
1261
proc->buffer_length);
1143
1262
if(not bret){
1144
perror("print_out_password");
1145
exitstatus = EXIT_FAILURE;
1263
error(0, errno, "print_out_password");
1264
exitstatus = EX_IOERR;
1146
1265
}
1147
1266
goto fallback;
1148
1267
}
1149
1268
1150
1269
/* This process has not completed. Does it have any output? */
1151
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1152
warning from
1153
-Wconversion */
1270
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1154
1271
/* This process had nothing to say at this time */
1155
1272
proc = proc->next;
1156
1273
continue;
1157
1274
}
1158
1275
/* Before reading, make the process' data buffer large enough */
1159
1276
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1160
proc->buffer = realloc(proc->buffer, proc->buffer_size
1161
+ (size_t) BUFFER_SIZE);
1162
if(proc->buffer == NULL){
1163
perror("malloc");
1164
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;
1165
1282
goto fallback;
1166
1283
}
1284
proc->buffer = new_buffer;
1167
1285
proc->buffer_size += BUFFER_SIZE;
1168
1286
}
1169
1287
/* Read from the process */
1188
1306
1189
1307
fallback:
1190
1308
1191
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1309
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1310
and exitstatus != EX_OK)){
1192
1311
/* Fallback if all plugins failed, none are found or an error
1193
1312
occured */
1194
1313
bool bret;
1202
1321
}
1203
1322
bret = print_out_password(passwordbuffer, len);
1204
1323
if(not bret){
1205
perror("print_out_password");
1206
exitstatus = EXIT_FAILURE;
1324
error(0, errno, "print_out_password");
1325
exitstatus = EX_IOERR;
1207
1326
}
1208
1327
}
1209
1328
1210
1329
/* Restore old signal handler */
1211
1330
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1212
1331
if(ret == -1){
1213
perror("sigaction");
1214
exitstatus = EXIT_FAILURE;
1332
error(0, errno, "sigaction");
1333
exitstatus = EX_OSERR;
1215
1334
}
1216
1335
1217
1336
if(custom_argv != NULL){
1221
1340
free(custom_argv);
1222
1341
}
1223
1342
1224
if(dir != NULL){
1225
closedir(dir);
1343
free(direntries);
1344
1345
if(dir_fd != -1){
1346
close(dir_fd);
1226
1347
}
1227
1348
1228
1349
/* Kill the processes */
1232
1353
ret = kill(p->pid, SIGTERM);
1233
1354
if(ret == -1 and errno != ESRCH){
1234
1355
/* Set-uid proccesses might not get closed */
1235
perror("kill");
1356
error(0, errno, "kill");
1236
1357
}
1237
1358
}
1238
1359
}
1242
1363
ret = wait(NULL);
1243
1364
} while(ret >= 0);
1244
1365
if(errno != ECHILD){
1245
perror("wait");
1366
error(0, errno, "wait");
1246
1367
}
1247
1368
1248
1369
free_plugin_list();
1249
1370
1250
1371
free(plugindir);
1372
free(pluginhelperdir);
1251
1373
free(argfile);
1252
1374
1253
1375
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0