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:
- bugs.xml
- debian/tests
- debian/upstream
- dracut-module
- 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-2012 Teddy Hogeborn
6
* Copyright © 2008-2012 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
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;
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 */
174
__attribute__((nonnull))
190
__attribute__((nonnull, warn_unused_result))
175
191
static bool add_to_char_array(const char *new, char ***array,
176
192
int *len){
177
193
/* Resize the pointed-to array to hold one more pointer */
194
char **new_array = NULL;
178
195
do {
179
*array = realloc(*array, sizeof(char *)
180
* (size_t) ((*len) + 2));
181
} 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);
182
210
/* Malloc check */
183
if(*array == NULL){
211
if(new_array == NULL){
184
212
return false;
185
213
}
214
*array = new_array;
186
215
/* Make a copy of the new string */
187
216
char *copy;
188
217
do {
200
229
}
201
230
202
231
/* Add to a plugin's argument vector */
203
__attribute__((nonnull(2)))
232
__attribute__((nonnull(2), warn_unused_result))
204
233
static bool add_argument(plugin *p, const char *arg){
205
234
if(p == NULL){
206
235
return false;
209
238
}
210
239
211
240
/* Add to a plugin's environment */
212
__attribute__((nonnull(2)))
241
__attribute__((nonnull(2), warn_unused_result))
213
242
static bool add_environment(plugin *p, const char *def, bool replace){
214
243
if(p == NULL){
215
244
return false;
217
246
/* namelen = length of name of environment variable */
218
247
size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
248
/* Search for this environment variable */
220
for(char **e = p->environ; *e != NULL; e++){
221
if(strncmp(*e, def, namelen + 1) == 0){
249
for(char **envdef = p->environ; *envdef != NULL; envdef++){
250
if(strncmp(*envdef, def, namelen + 1) == 0){
222
251
/* It already exists */
223
252
if(replace){
224
char *new;
253
char *new_envdef;
225
254
do {
226
new = realloc(*e, strlen(def) + 1);
227
} while(new == NULL and errno == EINTR);
228
if(new == NULL){
255
new_envdef = realloc(*envdef, strlen(def) + 1);
256
} while(new_envdef == NULL and errno == EINTR);
257
if(new_envdef == NULL){
229
258
return false;
230
259
}
231
*e = new;
232
strcpy(*e, def);
260
*envdef = new_envdef;
261
strcpy(*envdef, def);
233
262
}
234
263
return true;
235
264
}
237
266
return add_to_char_array(def, &(p->environ), &(p->envc));
238
267
}
239
268
269
#ifndef O_CLOEXEC
240
270
/*
241
271
* Based on the example in the GNU LibC manual chapter 13.13 "File
242
272
* Descriptor Flags".
243
273
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
244
274
*/
275
__attribute__((warn_unused_result))
245
276
static int set_cloexec_flag(int fd){
246
277
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
247
278
/* If reading the flags failed, return error indication now. */
252
283
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
284
ret | FD_CLOEXEC));
254
285
}
286
#endif /* not O_CLOEXEC */
255
287
256
288
257
289
/* Mark processes as completed when they exit, and save their exit
289
321
}
290
322
291
323
/* Prints out a password to stdout */
292
__attribute__((nonnull))
324
__attribute__((nonnull, warn_unused_result))
293
325
static bool print_out_password(const char *buffer, size_t length){
294
326
ssize_t ret;
295
327
for(size_t written = 0; written < length; written += (size_t)ret){
306
338
__attribute__((nonnull))
307
339
static void free_plugin(plugin *plugin_node){
308
340
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
341
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
310
342
free(*arg);
311
343
}
344
free(plugin_node->name);
312
345
free(plugin_node->argv);
313
346
for(char **env = plugin_node->environ; *env != NULL; env++){
314
347
free(*env);
341
374
342
375
int main(int argc, char *argv[]){
343
376
char *plugindir = NULL;
377
char *pluginhelperdir = NULL;
344
378
char *argfile = NULL;
345
379
FILE *conffp;
346
size_t d_name_len;
347
DIR *dir = NULL;
348
struct dirent *dirst;
380
struct dirent **direntries = NULL;
349
381
struct stat st;
350
382
fd_set rfds_all;
351
383
int ret, maxfd = 0;
359
391
.sa_flags = SA_NOCLDSTOP };
360
392
char **custom_argv = NULL;
361
393
int custom_argc = 0;
394
int dir_fd = -1;
362
395
363
396
/* Establish a signal handler */
364
397
sigemptyset(&sigchld_action.sa_mask);
409
442
.doc = "Group ID the plugins will run as", .group = 3 },
410
443
{ .name = "debug", .key = 132,
411
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 },
412
449
/*
413
450
* These reproduce what we would get without ARGP_NO_HELP
414
451
*/
435
472
break;
436
473
}
437
474
}
475
errno = 0;
438
476
}
439
477
break;
440
478
case 'G': /* --global-env */
441
add_environment(getplugin(NULL), arg, true);
479
if(add_environment(getplugin(NULL), arg, true)){
480
errno = 0;
481
}
442
482
break;
443
483
case 'o': /* --options-for */
444
484
{
461
501
break;
462
502
}
463
503
}
504
errno = 0;
464
505
}
465
506
break;
466
507
case 'E': /* --env-for */
478
519
errno = EINVAL;
479
520
break;
480
521
}
481
add_environment(getplugin(arg), envdef, true);
522
if(add_environment(getplugin(arg), envdef, true)){
523
errno = 0;
524
}
482
525
}
483
526
break;
484
527
case 'd': /* --disable */
486
529
plugin *p = getplugin(arg);
487
530
if(p != NULL){
488
531
p->disabled = true;
532
errno = 0;
489
533
}
490
534
}
491
535
break;
494
538
plugin *p = getplugin(arg);
495
539
if(p != NULL){
496
540
p->disabled = false;
541
errno = 0;
497
542
}
498
543
}
499
544
break;
500
545
case 128: /* --plugin-dir */
501
546
free(plugindir);
502
547
plugindir = strdup(arg);
548
if(plugindir != NULL){
549
errno = 0;
550
}
503
551
break;
504
552
case 129: /* --config-file */
505
553
/* This is already done by parse_opt_config_file() */
513
561
break;
514
562
}
515
563
uid = (uid_t)tmp_id;
564
errno = 0;
516
565
break;
517
566
case 131: /* --groupid */
518
567
tmp_id = strtoimax(arg, &tmp, 10);
523
572
break;
524
573
}
525
574
gid = (gid_t)tmp_id;
575
errno = 0;
526
576
break;
527
577
case 132: /* --debug */
528
578
debug = true;
529
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;
530
587
/*
531
588
* These reproduce what we would get without ARGP_NO_HELP
532
589
*/
533
590
case '?': /* --help */
534
591
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
535
592
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
593
__builtin_unreachable();
536
594
case -3: /* --usage */
537
595
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
538
596
argp_state_help(state, state->out_stream,
539
597
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
598
__builtin_unreachable();
540
599
case 'V': /* --version */
541
600
fprintf(state->out_stream, "%s\n", argp_program_version);
542
601
exit(EXIT_SUCCESS);
552
611
if(arg[0] == '\0'){
553
612
break;
554
613
}
614
#if __GNUC__ >= 7
615
__attribute__((fallthrough));
616
#else
617
/* FALLTHROUGH */
618
#endif
555
619
default:
556
620
return ARGP_ERR_UNKNOWN;
557
621
}
576
640
case 129: /* --config-file */
577
641
free(argfile);
578
642
argfile = strdup(arg);
643
if(argfile != NULL){
644
errno = 0;
645
}
579
646
break;
580
647
case 130: /* --userid */
581
648
case 131: /* --groupid */
582
649
case 132: /* --debug */
650
case 133: /* --plugin-helper-dir */
583
651
case '?': /* --help */
584
652
case -3: /* --usage */
585
653
case 'V': /* --version */
664
732
}
665
733
666
734
custom_argc += 1;
667
custom_argv = realloc(custom_argv, sizeof(char *)
668
* ((unsigned int) custom_argc + 1));
669
if(custom_argv == NULL){
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
672
free(org_line);
673
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
}
674
758
}
675
759
custom_argv[custom_argc-1] = new_arg;
676
760
custom_argv[custom_argc] = NULL;
734
818
goto fallback;
735
819
}
736
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
737
839
if(debug){
738
for(plugin *p = plugin_list; p != NULL; p=p->next){
840
for(plugin *p = plugin_list; p != NULL; p = p->next){
739
841
fprintf(stderr, "Plugin: %s has %d arguments\n",
740
842
p->name ? p->name : "Global", p->argc - 1);
741
843
for(char **a = p->argv; *a != NULL; a++){
750
852
751
853
if(getuid() == 0){
752
854
/* Work around Debian bug #633582:
753
<http://bugs.debian.org/633582> */
855
<https://bugs.debian.org/633582> */
754
856
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
755
857
if(plugindir_fd == -1){
756
error(0, errno, "open");
858
if(errno != ENOENT){
859
error(0, errno, "open(\"" PDIR "\")");
860
}
757
861
} else {
758
862
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
759
863
if(ret == -1){
766
870
}
767
871
}
768
872
}
769
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
}
770
883
}
771
884
}
772
885
773
886
/* Lower permissions */
774
setgid(gid);
887
ret = setgid(gid);
775
888
if(ret == -1){
776
889
error(0, errno, "setgid");
777
890
}
782
895
783
896
/* Open plugin directory with close_on_exec flag */
784
897
{
785
int dir_fd = -1;
786
if(plugindir == NULL){
787
dir_fd = open(PDIR, O_RDONLY |
788
#ifdef O_CLOEXEC
789
O_CLOEXEC
790
#else /* not O_CLOEXEC */
791
0
792
#endif /* not O_CLOEXEC */
793
);
794
} else {
795
dir_fd = open(plugindir, O_RDONLY |
796
#ifdef O_CLOEXEC
797
O_CLOEXEC
798
#else /* not O_CLOEXEC */
799
0
800
#endif /* not O_CLOEXEC */
801
);
802
}
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
);
803
905
if(dir_fd == -1){
804
906
error(0, errno, "Could not open plugin dir");
805
907
exitstatus = EX_UNAVAILABLE;
811
913
ret = set_cloexec_flag(dir_fd);
812
914
if(ret < 0){
813
915
error(0, errno, "set_cloexec_flag");
814
TEMP_FAILURE_RETRY(close(dir_fd));
815
916
exitstatus = EX_OSERR;
816
917
goto fallback;
817
918
}
818
919
#endif /* O_CLOEXEC */
819
820
dir = fdopendir(dir_fd);
821
if(dir == NULL){
822
error(0, errno, "Could not open plugin dir");
823
TEMP_FAILURE_RETRY(close(dir_fd));
824
exitstatus = EX_OSERR;
825
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
}
826
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;
827
954
}
828
955
829
956
FD_ZERO(&rfds_all);
830
957
831
958
/* Read and execute any executable in the plugin directory*/
832
while(true){
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
836
837
/* All directory entries have been processed */
838
if(dirst == NULL){
839
if(errno == EBADF){
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
842
goto fallback;
843
}
844
break;
845
}
846
847
d_name_len = strlen(dirst->d_name);
848
849
/* Ignore dotfiles, backup files and other junk */
850
{
851
bool bad_name = false;
852
853
const char const *bad_prefixes[] = { ".", "#", NULL };
854
855
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
856
".dpkg-old",
857
".dpkg-bak",
858
".dpkg-divert", NULL };
859
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
860
size_t pre_len = strlen(*pre);
861
if((d_name_len >= pre_len)
862
and strncmp((dirst->d_name), *pre, pre_len) == 0){
863
if(debug){
864
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
865
" with bad prefix %s\n", dirst->d_name, *pre);
866
}
867
bad_name = true;
868
break;
869
}
870
}
871
if(bad_name){
872
continue;
873
}
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
875
size_t suf_len = strlen(*suf);
876
if((d_name_len >= suf_len)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
878
== 0)){
879
if(debug){
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
881
" with bad suffix %s\n", dirst->d_name, *suf);
882
}
883
bad_name = true;
884
break;
885
}
886
}
887
888
if(bad_name){
889
continue;
890
}
891
}
892
893
char *filename;
894
if(plugindir == NULL){
895
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
dirst->d_name));
897
} else {
898
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
899
plugindir,
900
dirst->d_name));
901
}
902
if(ret < 0){
903
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]);
904
965
continue;
905
966
}
906
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
967
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
908
968
if(ret == -1){
909
969
error(0, errno, "stat");
910
free(filename);
970
close(plugin_fd);
971
free(direntries[i]);
911
972
continue;
912
973
}
913
974
914
975
/* Ignore non-executable files */
915
976
if(not S_ISREG(st.st_mode)
916
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)){
917
979
if(debug){
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
919
" 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);
920
984
}
921
free(filename);
985
close(plugin_fd);
986
free(direntries[i]);
922
987
continue;
923
988
}
924
989
925
plugin *p = getplugin(dirst->d_name);
990
plugin *p = getplugin(direntries[i]->d_name);
926
991
if(p == NULL){
927
992
error(0, errno, "getplugin");
928
free(filename);
993
close(plugin_fd);
994
free(direntries[i]);
929
995
continue;
930
996
}
931
997
if(p->disabled){
932
998
if(debug){
933
999
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
934
dirst->d_name);
1000
direntries[i]->d_name);
935
1001
}
936
free(filename);
1002
close(plugin_fd);
1003
free(direntries[i]);
937
1004
continue;
938
1005
}
939
1006
{
953
1020
}
954
1021
}
955
1022
}
956
/* If this plugin has any environment variables, we will call
957
using execve and need to duplicate the environment from this
958
process, too. */
1023
/* If this plugin has any environment variables, we need to
1024
duplicate the environment from this process, too. */
959
1025
if(p->environ[0] != NULL){
960
1026
for(char **e = environ; *e != NULL; e++){
961
1027
if(not add_environment(p, *e, false)){
965
1031
}
966
1032
967
1033
int pipefd[2];
1034
#ifndef O_CLOEXEC
968
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 */
969
1039
if(ret == -1){
970
1040
error(0, errno, "pipe");
971
1041
exitstatus = EX_OSERR;
972
goto fallback;
973
}
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
974
1055
/* Ask OS to automatic close the pipe on exec */
975
1056
ret = set_cloexec_flag(pipefd[0]);
976
1057
if(ret < 0){
977
1058
error(0, errno, "set_cloexec_flag");
1059
close(pipefd[0]);
1060
close(pipefd[1]);
978
1061
exitstatus = EX_OSERR;
1062
free(direntries[i]);
979
1063
goto fallback;
980
1064
}
981
1065
ret = set_cloexec_flag(pipefd[1]);
982
1066
if(ret < 0){
983
1067
error(0, errno, "set_cloexec_flag");
1068
close(pipefd[0]);
1069
close(pipefd[1]);
984
1070
exitstatus = EX_OSERR;
1071
free(direntries[i]);
985
1072
goto fallback;
986
1073
}
1074
#endif /* not O_CLOEXEC */
987
1075
/* Block SIGCHLD until process is safely in process list */
988
1076
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
989
1077
&sigchld_action.sa_mask,
991
1079
if(ret < 0){
992
1080
error(0, errno, "sigprocmask");
993
1081
exitstatus = EX_OSERR;
1082
free(direntries[i]);
994
1083
goto fallback;
995
1084
}
996
1085
/* Starting a new process to be watched */
1000
1089
} while(pid == -1 and errno == EINTR);
1001
1090
if(pid == -1){
1002
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]);
1003
1096
exitstatus = EX_OSERR;
1097
free(direntries[i]);
1004
1098
goto fallback;
1005
1099
}
1006
1100
if(pid == 0){
1022
1116
_exit(EX_OSERR);
1023
1117
}
1024
1118
1025
if(dirfd(dir) < 0){
1026
/* If dir has no file descriptor, we could not set FD_CLOEXEC
1027
above and must now close it manually here. */
1028
closedir(dir);
1029
}
1030
if(p->environ[0] == NULL){
1031
if(execv(filename, p->argv) < 0){
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
1034
}
1035
} else {
1036
if(execve(filename, p->argv, p->environ) < 0){
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
1039
}
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);
1040
1125
}
1041
1126
/* no return */
1042
1127
}
1043
1128
/* Parent process */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
1046
free(filename);
1047
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);
1048
1132
if(new_plugin == NULL){
1049
1133
error(0, errno, "getplugin");
1050
1134
ret = (int)(TEMP_FAILURE_RETRY
1054
1138
error(0, errno, "sigprocmask");
1055
1139
}
1056
1140
exitstatus = EX_OSERR;
1141
free(direntries[i]);
1057
1142
goto fallback;
1058
1143
}
1144
free(direntries[i]);
1059
1145
1060
1146
new_plugin->pid = pid;
1061
1147
new_plugin->fd = pipefd[0];
1062
1148
1149
if(debug){
1150
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1151
new_plugin->name, (intmax_t) (new_plugin->pid));
1152
}
1153
1063
1154
/* Unblock SIGCHLD so signal handler can be run if this process
1064
1155
has already completed */
1065
1156
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1071
1162
goto fallback;
1072
1163
}
1073
1164
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
1165
FD_SET(new_plugin->fd, &rfds_all);
1076
1166
1077
1167
if(maxfd < new_plugin->fd){
1078
1168
maxfd = new_plugin->fd;
1079
1169
}
1080
1170
}
1081
1171
1082
TEMP_FAILURE_RETRY(closedir(dir));
1083
dir = NULL;
1172
free(direntries);
1173
direntries = NULL;
1174
close(dir_fd);
1175
dir_fd = -1;
1084
1176
free_plugin(getplugin(NULL));
1085
1177
1086
1178
for(plugin *p = plugin_list; p != NULL; p = p->next){
1125
1217
(intmax_t) (proc->pid),
1126
1218
WTERMSIG(proc->status),
1127
1219
strsignal(WTERMSIG(proc->status)));
1128
} else if(WCOREDUMP(proc->status)){
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1130
" core\n", proc->name, (intmax_t) (proc->pid));
1131
1220
}
1132
1221
}
1133
1222
1134
1223
/* Remove the plugin */
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
1224
FD_CLR(proc->fd, &rfds_all);
1137
1225
1138
1226
/* Block signal while modifying process_list */
1139
1227
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1179
1267
}
1180
1268
1181
1269
/* This process has not completed. Does it have any output? */
1182
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1183
warning from
1184
-Wconversion */
1270
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1185
1271
/* This process had nothing to say at this time */
1186
1272
proc = proc->next;
1187
1273
continue;
1188
1274
}
1189
1275
/* Before reading, make the process' data buffer large enough */
1190
1276
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
1192
+ (size_t) BUFFER_SIZE);
1193
if(proc->buffer == NULL){
1277
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1278
+ (size_t) BUFFER_SIZE);
1279
if(new_buffer == NULL){
1194
1280
error(0, errno, "malloc");
1195
1281
exitstatus = EX_OSERR;
1196
1282
goto fallback;
1197
1283
}
1284
proc->buffer = new_buffer;
1198
1285
proc->buffer_size += BUFFER_SIZE;
1199
1286
}
1200
1287
/* Read from the process */
1253
1340
free(custom_argv);
1254
1341
}
1255
1342
1256
if(dir != NULL){
1257
closedir(dir);
1343
free(direntries);
1344
1345
if(dir_fd != -1){
1346
close(dir_fd);
1258
1347
}
1259
1348
1260
1349
/* Kill the processes */
1280
1369
free_plugin_list();
1281
1370
1282
1371
free(plugindir);
1372
free(pluginhelperdir);
1283
1373
free(argfile);
1284
1374
1285
1375
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0