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:
- bugs.xml
- 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-2010 Teddy Hogeborn
6
* Copyright © 2008-2010 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_SUCCESS,
29
realloc() */
30
#include <stdbool.h> /* bool, true, false */
31
#include <stdio.h> /* 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(), strcmp(), strncmp() */
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 */
71
84
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,
72
85
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
#include <errno.h> /* errno */
74
#include <error.h> /* error() */
86
#include <inttypes.h> /* intmax_t, strtoimax(), PRIdMAX */
87
#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME,
88
FNM_PERIOD, FNM_NOMATCH */
75
89
76
90
#define BUFFER_SIZE 256
77
91
78
92
#define PDIR "/lib/mandos/plugins.d"
93
#define PHDIR "/lib/mandos/plugin-helpers"
79
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
95
81
96
const char *argp_program_version = "plugin-runner " VERSION;
82
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
83
98
84
99
typedef struct plugin{
85
100
char *name; /* can be NULL or any plugin name */
105
120
106
121
/* Gets an existing plugin based on name,
107
122
or if none is found, creates a new one */
123
__attribute__((warn_unused_result))
108
124
static plugin *getplugin(char *name){
109
125
/* Check for existing plugin with that name */
110
126
for(plugin *p = plugin_list; p != NULL; p = p->next){
171
187
}
172
188
173
189
/* Helper function for add_argument and add_environment */
190
__attribute__((nonnull, warn_unused_result))
174
191
static bool add_to_char_array(const char *new, char ***array,
175
192
int *len){
176
193
/* Resize the pointed-to array to hold one more pointer */
194
char **new_array = NULL;
177
195
do {
178
*array = realloc(*array, sizeof(char *)
179
* (size_t) ((*len) + 2));
180
} 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);
181
210
/* Malloc check */
182
if(*array == NULL){
211
if(new_array == NULL){
183
212
return false;
184
213
}
214
*array = new_array;
185
215
/* Make a copy of the new string */
186
216
char *copy;
187
217
do {
199
229
}
200
230
201
231
/* Add to a plugin's argument vector */
232
__attribute__((nonnull(2), warn_unused_result))
202
233
static bool add_argument(plugin *p, const char *arg){
203
234
if(p == NULL){
204
235
return false;
207
238
}
208
239
209
240
/* Add to a plugin's environment */
241
__attribute__((nonnull(2), warn_unused_result))
210
242
static bool add_environment(plugin *p, const char *def, bool replace){
211
243
if(p == NULL){
212
244
return false;
214
246
/* namelen = length of name of environment variable */
215
247
size_t namelen = (size_t)(strchrnul(def, '=') - def);
216
248
/* Search for this environment variable */
217
for(char **e = p->environ; *e != NULL; e++){
218
if(strncmp(*e, def, namelen + 1) == 0){
249
for(char **envdef = p->environ; *envdef != NULL; envdef++){
250
if(strncmp(*envdef, def, namelen + 1) == 0){
219
251
/* It already exists */
220
252
if(replace){
221
char *new;
253
char *new_envdef;
222
254
do {
223
new = realloc(*e, strlen(def) + 1);
224
} while(new == NULL and errno == EINTR);
225
if(new == NULL){
255
new_envdef = realloc(*envdef, strlen(def) + 1);
256
} while(new_envdef == NULL and errno == EINTR);
257
if(new_envdef == NULL){
226
258
return false;
227
259
}
228
*e = new;
229
strcpy(*e, def);
260
*envdef = new_envdef;
261
strcpy(*envdef, def);
230
262
}
231
263
return true;
232
264
}
234
266
return add_to_char_array(def, &(p->environ), &(p->envc));
235
267
}
236
268
269
#ifndef O_CLOEXEC
237
270
/*
238
271
* Based on the example in the GNU LibC manual chapter 13.13 "File
239
272
* Descriptor Flags".
240
273
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
241
274
*/
275
__attribute__((warn_unused_result))
242
276
static int set_cloexec_flag(int fd){
243
277
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
244
278
/* If reading the flags failed, return error indication now. */
249
283
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
250
284
ret | FD_CLOEXEC));
251
285
}
286
#endif /* not O_CLOEXEC */
252
287
253
288
254
289
/* Mark processes as completed when they exit, and save their exit
286
321
}
287
322
288
323
/* Prints out a password to stdout */
324
__attribute__((nonnull, warn_unused_result))
289
325
static bool print_out_password(const char *buffer, size_t length){
290
326
ssize_t ret;
291
327
for(size_t written = 0; written < length; written += (size_t)ret){
299
335
}
300
336
301
337
/* Removes and free a plugin from the plugin list */
338
__attribute__((nonnull))
302
339
static void free_plugin(plugin *plugin_node){
303
340
304
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
341
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
305
342
free(*arg);
306
343
}
344
free(plugin_node->name);
307
345
free(plugin_node->argv);
308
346
for(char **env = plugin_node->environ; *env != NULL; env++){
309
347
free(*env);
336
374
337
375
int main(int argc, char *argv[]){
338
376
char *plugindir = NULL;
377
char *pluginhelperdir = NULL;
339
378
char *argfile = NULL;
340
379
FILE *conffp;
341
size_t d_name_len;
342
DIR *dir = NULL;
343
struct dirent *dirst;
380
struct dirent **direntries = NULL;
344
381
struct stat st;
345
382
fd_set rfds_all;
346
383
int ret, maxfd = 0;
354
391
.sa_flags = SA_NOCLDSTOP };
355
392
char **custom_argv = NULL;
356
393
int custom_argc = 0;
394
int dir_fd = -1;
357
395
358
396
/* Establish a signal handler */
359
397
sigemptyset(&sigchld_action.sa_mask);
404
442
.doc = "Group ID the plugins will run as", .group = 3 },
405
443
{ .name = "debug", .key = 132,
406
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 },
407
449
/*
408
450
* These reproduce what we would get without ARGP_NO_HELP
409
451
*/
416
458
{ .name = NULL }
417
459
};
418
460
461
__attribute__((nonnull(3)))
419
462
error_t parse_opt(int key, char *arg, struct argp_state *state){
420
463
errno = 0;
421
464
switch(key){
422
465
char *tmp;
423
intmax_t tmpmax;
466
intmax_t tmp_id;
424
467
case 'g': /* --global-options */
425
468
{
426
469
char *plugin_option;
429
472
break;
430
473
}
431
474
}
475
errno = 0;
432
476
}
433
477
break;
434
478
case 'G': /* --global-env */
435
add_environment(getplugin(NULL), arg, true);
479
if(add_environment(getplugin(NULL), arg, true)){
480
errno = 0;
481
}
436
482
break;
437
483
case 'o': /* --options-for */
438
484
{
455
501
break;
456
502
}
457
503
}
504
errno = 0;
458
505
}
459
506
break;
460
507
case 'E': /* --env-for */
472
519
errno = EINVAL;
473
520
break;
474
521
}
475
add_environment(getplugin(arg), envdef, true);
522
if(add_environment(getplugin(arg), envdef, true)){
523
errno = 0;
524
}
476
525
}
477
526
break;
478
527
case 'd': /* --disable */
480
529
plugin *p = getplugin(arg);
481
530
if(p != NULL){
482
531
p->disabled = true;
532
errno = 0;
483
533
}
484
534
}
485
535
break;
488
538
plugin *p = getplugin(arg);
489
539
if(p != NULL){
490
540
p->disabled = false;
541
errno = 0;
491
542
}
492
543
}
493
544
break;
494
545
case 128: /* --plugin-dir */
495
546
free(plugindir);
496
547
plugindir = strdup(arg);
548
if(plugindir != NULL){
549
errno = 0;
550
}
497
551
break;
498
552
case 129: /* --config-file */
499
553
/* This is already done by parse_opt_config_file() */
500
554
break;
501
555
case 130: /* --userid */
502
tmpmax = strtoimax(arg, &tmp, 10);
556
tmp_id = strtoimax(arg, &tmp, 10);
503
557
if(errno != 0 or tmp == arg or *tmp != '\0'
504
or tmpmax != (uid_t)tmpmax){
558
or tmp_id != (uid_t)tmp_id){
505
559
argp_error(state, "Bad user ID number: \"%s\", using %"
506
560
PRIdMAX, arg, (intmax_t)uid);
507
561
break;
508
562
}
509
uid = (uid_t)tmpmax;
563
uid = (uid_t)tmp_id;
564
errno = 0;
510
565
break;
511
566
case 131: /* --groupid */
512
tmpmax = strtoimax(arg, &tmp, 10);
567
tmp_id = strtoimax(arg, &tmp, 10);
513
568
if(errno != 0 or tmp == arg or *tmp != '\0'
514
or tmpmax != (gid_t)tmpmax){
569
or tmp_id != (gid_t)tmp_id){
515
570
argp_error(state, "Bad group ID number: \"%s\", using %"
516
571
PRIdMAX, arg, (intmax_t)gid);
517
572
break;
518
573
}
519
gid = (gid_t)tmpmax;
574
gid = (gid_t)tmp_id;
575
errno = 0;
520
576
break;
521
577
case 132: /* --debug */
522
578
debug = true;
523
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;
524
587
/*
525
588
* These reproduce what we would get without ARGP_NO_HELP
526
589
*/
527
590
case '?': /* --help */
528
591
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
529
592
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
593
__builtin_unreachable();
530
594
case -3: /* --usage */
531
595
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
532
596
argp_state_help(state, state->out_stream,
533
597
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
598
__builtin_unreachable();
534
599
case 'V': /* --version */
535
600
fprintf(state->out_stream, "%s\n", argp_program_version);
536
601
exit(EXIT_SUCCESS);
546
611
if(arg[0] == '\0'){
547
612
break;
548
613
}
614
#if __GNUC__ >= 7
615
__attribute__((fallthrough));
616
#else
617
/* FALLTHROUGH */
618
#endif
549
619
default:
550
620
return ARGP_ERR_UNKNOWN;
551
621
}
570
640
case 129: /* --config-file */
571
641
free(argfile);
572
642
argfile = strdup(arg);
643
if(argfile != NULL){
644
errno = 0;
645
}
573
646
break;
574
647
case 130: /* --userid */
575
648
case 131: /* --groupid */
576
649
case 132: /* --debug */
650
case 133: /* --plugin-helper-dir */
577
651
case '?': /* --help */
578
652
case -3: /* --usage */
579
653
case 'V': /* --version */
658
732
}
659
733
660
734
custom_argc += 1;
661
custom_argv = realloc(custom_argv, sizeof(char *)
662
* ((unsigned int) custom_argc + 1));
663
if(custom_argv == NULL){
664
error(0, errno, "realloc");
665
exitstatus = EX_OSERR;
666
free(org_line);
667
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
}
668
758
}
669
759
custom_argv[custom_argc-1] = new_arg;
670
760
custom_argv[custom_argc] = NULL;
728
818
goto fallback;
729
819
}
730
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
731
839
if(debug){
732
for(plugin *p = plugin_list; p != NULL; p=p->next){
840
for(plugin *p = plugin_list; p != NULL; p = p->next){
733
841
fprintf(stderr, "Plugin: %s has %d arguments\n",
734
842
p->name ? p->name : "Global", p->argc - 1);
735
843
for(char **a = p->argv; *a != NULL; a++){
742
850
}
743
851
}
744
852
745
{
853
if(getuid() == 0){
746
854
/* Work around Debian bug #633582:
747
<http://bugs.debian.org/633582> */
855
<https://bugs.debian.org/633582> */
748
856
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
749
857
if(plugindir_fd == -1){
750
error(0, errno, "open");
858
if(errno != ENOENT){
859
error(0, errno, "open(\"" PDIR "\")");
860
}
751
861
} else {
752
862
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
753
863
if(ret == -1){
760
870
}
761
871
}
762
872
}
763
TEMP_FAILURE_RETRY(close(plugindir_fd));
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
}
764
883
}
765
884
}
766
885
767
886
/* Lower permissions */
768
setgid(gid);
887
ret = setgid(gid);
769
888
if(ret == -1){
770
889
error(0, errno, "setgid");
771
890
}
776
895
777
896
/* Open plugin directory with close_on_exec flag */
778
897
{
779
int dir_fd = -1;
780
if(plugindir == NULL){
781
dir_fd = open(PDIR, O_RDONLY |
782
#ifdef O_CLOEXEC
783
O_CLOEXEC
784
#else /* not O_CLOEXEC */
785
0
786
#endif /* not O_CLOEXEC */
787
);
788
} else {
789
dir_fd = open(plugindir, O_RDONLY |
790
#ifdef O_CLOEXEC
791
O_CLOEXEC
792
#else /* not O_CLOEXEC */
793
0
794
#endif /* not O_CLOEXEC */
795
);
796
}
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
);
797
905
if(dir_fd == -1){
798
906
error(0, errno, "Could not open plugin dir");
799
907
exitstatus = EX_UNAVAILABLE;
805
913
ret = set_cloexec_flag(dir_fd);
806
914
if(ret < 0){
807
915
error(0, errno, "set_cloexec_flag");
808
TEMP_FAILURE_RETRY(close(dir_fd));
809
916
exitstatus = EX_OSERR;
810
917
goto fallback;
811
918
}
812
919
#endif /* O_CLOEXEC */
813
814
dir = fdopendir(dir_fd);
815
if(dir == NULL){
816
error(0, errno, "Could not open plugin dir");
817
TEMP_FAILURE_RETRY(close(dir_fd));
818
exitstatus = EX_OSERR;
819
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
}
820
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;
821
954
}
822
955
823
956
FD_ZERO(&rfds_all);
824
957
825
958
/* Read and execute any executable in the plugin directory*/
826
while(true){
827
do {
828
dirst = readdir(dir);
829
} while(dirst == NULL and errno == EINTR);
830
831
/* All directory entries have been processed */
832
if(dirst == NULL){
833
if(errno == EBADF){
834
error(0, errno, "readdir");
835
exitstatus = EX_IOERR;
836
goto fallback;
837
}
838
break;
839
}
840
841
d_name_len = strlen(dirst->d_name);
842
843
/* Ignore dotfiles, backup files and other junk */
844
{
845
bool bad_name = false;
846
847
const char const *bad_prefixes[] = { ".", "#", NULL };
848
849
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
850
".dpkg-old",
851
".dpkg-bak",
852
".dpkg-divert", NULL };
853
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
854
size_t pre_len = strlen(*pre);
855
if((d_name_len >= pre_len)
856
and strncmp((dirst->d_name), *pre, pre_len) == 0){
857
if(debug){
858
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
859
" with bad prefix %s\n", dirst->d_name, *pre);
860
}
861
bad_name = true;
862
break;
863
}
864
}
865
if(bad_name){
866
continue;
867
}
868
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
869
size_t suf_len = strlen(*suf);
870
if((d_name_len >= suf_len)
871
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
872
== 0)){
873
if(debug){
874
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
875
" with bad suffix %s\n", dirst->d_name, *suf);
876
}
877
bad_name = true;
878
break;
879
}
880
}
881
882
if(bad_name){
883
continue;
884
}
885
}
886
887
char *filename;
888
if(plugindir == NULL){
889
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
890
dirst->d_name));
891
} else {
892
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
893
plugindir,
894
dirst->d_name));
895
}
896
if(ret < 0){
897
error(0, errno, "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]);
898
965
continue;
899
966
}
900
901
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
967
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
902
968
if(ret == -1){
903
969
error(0, errno, "stat");
904
free(filename);
970
close(plugin_fd);
971
free(direntries[i]);
905
972
continue;
906
973
}
907
974
908
975
/* Ignore non-executable files */
909
976
if(not S_ISREG(st.st_mode)
910
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)){
911
979
if(debug){
912
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
913
" 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);
914
984
}
915
free(filename);
985
close(plugin_fd);
986
free(direntries[i]);
916
987
continue;
917
988
}
918
989
919
plugin *p = getplugin(dirst->d_name);
990
plugin *p = getplugin(direntries[i]->d_name);
920
991
if(p == NULL){
921
992
error(0, errno, "getplugin");
922
free(filename);
993
close(plugin_fd);
994
free(direntries[i]);
923
995
continue;
924
996
}
925
997
if(p->disabled){
926
998
if(debug){
927
999
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
928
dirst->d_name);
1000
direntries[i]->d_name);
929
1001
}
930
free(filename);
1002
close(plugin_fd);
1003
free(direntries[i]);
931
1004
continue;
932
1005
}
933
1006
{
947
1020
}
948
1021
}
949
1022
}
950
/* If this plugin has any environment variables, we will call
951
using execve and need to duplicate the environment from this
952
process, too. */
1023
/* If this plugin has any environment variables, we need to
1024
duplicate the environment from this process, too. */
953
1025
if(p->environ[0] != NULL){
954
1026
for(char **e = environ; *e != NULL; e++){
955
1027
if(not add_environment(p, *e, false)){
959
1031
}
960
1032
961
1033
int pipefd[2];
1034
#ifndef O_CLOEXEC
962
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 */
963
1039
if(ret == -1){
964
1040
error(0, errno, "pipe");
965
1041
exitstatus = EX_OSERR;
966
goto fallback;
967
}
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
968
1055
/* Ask OS to automatic close the pipe on exec */
969
1056
ret = set_cloexec_flag(pipefd[0]);
970
1057
if(ret < 0){
971
1058
error(0, errno, "set_cloexec_flag");
1059
close(pipefd[0]);
1060
close(pipefd[1]);
972
1061
exitstatus = EX_OSERR;
1062
free(direntries[i]);
973
1063
goto fallback;
974
1064
}
975
1065
ret = set_cloexec_flag(pipefd[1]);
976
1066
if(ret < 0){
977
1067
error(0, errno, "set_cloexec_flag");
1068
close(pipefd[0]);
1069
close(pipefd[1]);
978
1070
exitstatus = EX_OSERR;
1071
free(direntries[i]);
979
1072
goto fallback;
980
1073
}
1074
#endif /* not O_CLOEXEC */
981
1075
/* Block SIGCHLD until process is safely in process list */
982
1076
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
983
1077
&sigchld_action.sa_mask,
985
1079
if(ret < 0){
986
1080
error(0, errno, "sigprocmask");
987
1081
exitstatus = EX_OSERR;
1082
free(direntries[i]);
988
1083
goto fallback;
989
1084
}
990
1085
/* Starting a new process to be watched */
994
1089
} while(pid == -1 and errno == EINTR);
995
1090
if(pid == -1){
996
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]);
997
1096
exitstatus = EX_OSERR;
1097
free(direntries[i]);
998
1098
goto fallback;
999
1099
}
1000
1100
if(pid == 0){
1016
1116
_exit(EX_OSERR);
1017
1117
}
1018
1118
1019
if(dirfd(dir) < 0){
1020
/* If dir has no file descriptor, we could not set FD_CLOEXEC
1021
above and must now close it manually here. */
1022
closedir(dir);
1023
}
1024
if(p->environ[0] == NULL){
1025
if(execv(filename, p->argv) < 0){
1026
error(0, errno, "execv for %s", filename);
1027
_exit(EX_OSERR);
1028
}
1029
} else {
1030
if(execve(filename, p->argv, p->environ) < 0){
1031
error(0, errno, "execve for %s", filename);
1032
_exit(EX_OSERR);
1033
}
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);
1034
1125
}
1035
1126
/* no return */
1036
1127
}
1037
1128
/* Parent process */
1038
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1039
pipe */
1040
free(filename);
1041
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);
1042
1132
if(new_plugin == NULL){
1043
1133
error(0, errno, "getplugin");
1044
1134
ret = (int)(TEMP_FAILURE_RETRY
1048
1138
error(0, errno, "sigprocmask");
1049
1139
}
1050
1140
exitstatus = EX_OSERR;
1141
free(direntries[i]);
1051
1142
goto fallback;
1052
1143
}
1144
free(direntries[i]);
1053
1145
1054
1146
new_plugin->pid = pid;
1055
1147
new_plugin->fd = pipefd[0];
1056
1148
1149
if(debug){
1150
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1151
new_plugin->name, (intmax_t) (new_plugin->pid));
1152
}
1153
1057
1154
/* Unblock SIGCHLD so signal handler can be run if this process
1058
1155
has already completed */
1059
1156
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1065
1162
goto fallback;
1066
1163
}
1067
1164
1068
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1069
-Wconversion */
1165
FD_SET(new_plugin->fd, &rfds_all);
1070
1166
1071
1167
if(maxfd < new_plugin->fd){
1072
1168
maxfd = new_plugin->fd;
1073
1169
}
1074
1170
}
1075
1171
1076
TEMP_FAILURE_RETRY(closedir(dir));
1077
dir = NULL;
1172
free(direntries);
1173
direntries = NULL;
1174
close(dir_fd);
1175
dir_fd = -1;
1078
1176
free_plugin(getplugin(NULL));
1079
1177
1080
1178
for(plugin *p = plugin_list; p != NULL; p = p->next){
1119
1217
(intmax_t) (proc->pid),
1120
1218
WTERMSIG(proc->status),
1121
1219
strsignal(WTERMSIG(proc->status)));
1122
} else if(WCOREDUMP(proc->status)){
1123
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1124
" core\n", proc->name, (intmax_t) (proc->pid));
1125
1220
}
1126
1221
}
1127
1222
1128
1223
/* Remove the plugin */
1129
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1130
-Wconversion */
1224
FD_CLR(proc->fd, &rfds_all);
1131
1225
1132
1226
/* Block signal while modifying process_list */
1133
1227
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1173
1267
}
1174
1268
1175
1269
/* This process has not completed. Does it have any output? */
1176
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1177
warning from
1178
-Wconversion */
1270
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1179
1271
/* This process had nothing to say at this time */
1180
1272
proc = proc->next;
1181
1273
continue;
1182
1274
}
1183
1275
/* Before reading, make the process' data buffer large enough */
1184
1276
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1185
proc->buffer = realloc(proc->buffer, proc->buffer_size
1186
+ (size_t) BUFFER_SIZE);
1187
if(proc->buffer == NULL){
1277
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1278
+ (size_t) BUFFER_SIZE);
1279
if(new_buffer == NULL){
1188
1280
error(0, errno, "malloc");
1189
1281
exitstatus = EX_OSERR;
1190
1282
goto fallback;
1191
1283
}
1284
proc->buffer = new_buffer;
1192
1285
proc->buffer_size += BUFFER_SIZE;
1193
1286
}
1194
1287
/* Read from the process */
1247
1340
free(custom_argv);
1248
1341
}
1249
1342
1250
if(dir != NULL){
1251
closedir(dir);
1343
free(direntries);
1344
1345
if(dir_fd != -1){
1346
close(dir_fd);
1252
1347
}
1253
1348
1254
1349
/* Kill the processes */
1274
1369
free_plugin_list();
1275
1370
1276
1371
free(plugindir);
1372
free(pluginhelperdir);
1277
1373
free(argfile);
1278
1374
1279
1375
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0