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
/* Strip permissions down to nobody */
746
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);
747
888
if(ret == -1){
748
889
error(0, errno, "setgid");
749
890
}
754
895
755
896
/* Open plugin directory with close_on_exec flag */
756
897
{
757
int dir_fd = -1;
758
if(plugindir == NULL){
759
dir_fd = open(PDIR, O_RDONLY |
760
#ifdef O_CLOEXEC
761
O_CLOEXEC
762
#else /* not O_CLOEXEC */
763
0
764
#endif /* not O_CLOEXEC */
765
);
766
} else {
767
dir_fd = open(plugindir, O_RDONLY |
768
#ifdef O_CLOEXEC
769
O_CLOEXEC
770
#else /* not O_CLOEXEC */
771
0
772
#endif /* not O_CLOEXEC */
773
);
774
}
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
);
775
905
if(dir_fd == -1){
776
906
error(0, errno, "Could not open plugin dir");
777
907
exitstatus = EX_UNAVAILABLE;
783
913
ret = set_cloexec_flag(dir_fd);
784
914
if(ret < 0){
785
915
error(0, errno, "set_cloexec_flag");
786
TEMP_FAILURE_RETRY(close(dir_fd));
787
916
exitstatus = EX_OSERR;
788
917
goto fallback;
789
918
}
790
919
#endif /* O_CLOEXEC */
791
792
dir = fdopendir(dir_fd);
793
if(dir == NULL){
794
error(0, errno, "Could not open plugin dir");
795
TEMP_FAILURE_RETRY(close(dir_fd));
796
exitstatus = EX_OSERR;
797
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
}
798
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;
799
954
}
800
955
801
956
FD_ZERO(&rfds_all);
802
957
803
958
/* Read and execute any executable in the plugin directory*/
804
while(true){
805
do {
806
dirst = readdir(dir);
807
} while(dirst == NULL and errno == EINTR);
808
809
/* All directory entries have been processed */
810
if(dirst == NULL){
811
if(errno == EBADF){
812
error(0, errno, "readdir");
813
exitstatus = EX_IOERR;
814
goto fallback;
815
}
816
break;
817
}
818
819
d_name_len = strlen(dirst->d_name);
820
821
/* Ignore dotfiles, backup files and other junk */
822
{
823
bool bad_name = false;
824
825
const char const *bad_prefixes[] = { ".", "#", NULL };
826
827
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
828
".dpkg-old",
829
".dpkg-bak",
830
".dpkg-divert", NULL };
831
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
832
size_t pre_len = strlen(*pre);
833
if((d_name_len >= pre_len)
834
and strncmp((dirst->d_name), *pre, pre_len) == 0){
835
if(debug){
836
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
837
" with bad prefix %s\n", dirst->d_name, *pre);
838
}
839
bad_name = true;
840
break;
841
}
842
}
843
if(bad_name){
844
continue;
845
}
846
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
847
size_t suf_len = strlen(*suf);
848
if((d_name_len >= suf_len)
849
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
850
== 0)){
851
if(debug){
852
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
853
" with bad suffix %s\n", dirst->d_name, *suf);
854
}
855
bad_name = true;
856
break;
857
}
858
}
859
860
if(bad_name){
861
continue;
862
}
863
}
864
865
char *filename;
866
if(plugindir == NULL){
867
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
868
dirst->d_name));
869
} else {
870
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
871
plugindir,
872
dirst->d_name));
873
}
874
if(ret < 0){
875
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]);
876
965
continue;
877
966
}
878
879
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
967
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
880
968
if(ret == -1){
881
969
error(0, errno, "stat");
882
free(filename);
970
close(plugin_fd);
971
free(direntries[i]);
883
972
continue;
884
973
}
885
974
886
975
/* Ignore non-executable files */
887
976
if(not S_ISREG(st.st_mode)
888
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)){
889
979
if(debug){
890
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
891
" 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);
892
984
}
893
free(filename);
985
close(plugin_fd);
986
free(direntries[i]);
894
987
continue;
895
988
}
896
989
897
plugin *p = getplugin(dirst->d_name);
990
plugin *p = getplugin(direntries[i]->d_name);
898
991
if(p == NULL){
899
992
error(0, errno, "getplugin");
900
free(filename);
993
close(plugin_fd);
994
free(direntries[i]);
901
995
continue;
902
996
}
903
997
if(p->disabled){
904
998
if(debug){
905
999
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
906
dirst->d_name);
1000
direntries[i]->d_name);
907
1001
}
908
free(filename);
1002
close(plugin_fd);
1003
free(direntries[i]);
909
1004
continue;
910
1005
}
911
1006
{
925
1020
}
926
1021
}
927
1022
}
928
/* If this plugin has any environment variables, we will call
929
using execve and need to duplicate the environment from this
930
process, too. */
1023
/* If this plugin has any environment variables, we need to
1024
duplicate the environment from this process, too. */
931
1025
if(p->environ[0] != NULL){
932
1026
for(char **e = environ; *e != NULL; e++){
933
1027
if(not add_environment(p, *e, false)){
937
1031
}
938
1032
939
1033
int pipefd[2];
1034
#ifndef O_CLOEXEC
940
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 */
941
1039
if(ret == -1){
942
1040
error(0, errno, "pipe");
943
1041
exitstatus = EX_OSERR;
944
goto fallback;
945
}
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
946
1055
/* Ask OS to automatic close the pipe on exec */
947
1056
ret = set_cloexec_flag(pipefd[0]);
948
1057
if(ret < 0){
949
1058
error(0, errno, "set_cloexec_flag");
1059
close(pipefd[0]);
1060
close(pipefd[1]);
950
1061
exitstatus = EX_OSERR;
1062
free(direntries[i]);
951
1063
goto fallback;
952
1064
}
953
1065
ret = set_cloexec_flag(pipefd[1]);
954
1066
if(ret < 0){
955
1067
error(0, errno, "set_cloexec_flag");
1068
close(pipefd[0]);
1069
close(pipefd[1]);
956
1070
exitstatus = EX_OSERR;
1071
free(direntries[i]);
957
1072
goto fallback;
958
1073
}
1074
#endif /* not O_CLOEXEC */
959
1075
/* Block SIGCHLD until process is safely in process list */
960
1076
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
961
1077
&sigchld_action.sa_mask,
963
1079
if(ret < 0){
964
1080
error(0, errno, "sigprocmask");
965
1081
exitstatus = EX_OSERR;
1082
free(direntries[i]);
966
1083
goto fallback;
967
1084
}
968
1085
/* Starting a new process to be watched */
972
1089
} while(pid == -1 and errno == EINTR);
973
1090
if(pid == -1){
974
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]);
975
1096
exitstatus = EX_OSERR;
1097
free(direntries[i]);
976
1098
goto fallback;
977
1099
}
978
1100
if(pid == 0){
994
1116
_exit(EX_OSERR);
995
1117
}
996
1118
997
if(dirfd(dir) < 0){
998
/* If dir has no file descriptor, we could not set FD_CLOEXEC
999
above and must now close it manually here. */
1000
closedir(dir);
1001
}
1002
if(p->environ[0] == NULL){
1003
if(execv(filename, p->argv) < 0){
1004
error(0, errno, "execv for %s", filename);
1005
_exit(EX_OSERR);
1006
}
1007
} else {
1008
if(execve(filename, p->argv, p->environ) < 0){
1009
error(0, errno, "execve for %s", filename);
1010
_exit(EX_OSERR);
1011
}
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);
1012
1125
}
1013
1126
/* no return */
1014
1127
}
1015
1128
/* Parent process */
1016
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1017
pipe */
1018
free(filename);
1019
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);
1020
1132
if(new_plugin == NULL){
1021
1133
error(0, errno, "getplugin");
1022
1134
ret = (int)(TEMP_FAILURE_RETRY
1026
1138
error(0, errno, "sigprocmask");
1027
1139
}
1028
1140
exitstatus = EX_OSERR;
1141
free(direntries[i]);
1029
1142
goto fallback;
1030
1143
}
1144
free(direntries[i]);
1031
1145
1032
1146
new_plugin->pid = pid;
1033
1147
new_plugin->fd = pipefd[0];
1034
1148
1149
if(debug){
1150
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1151
new_plugin->name, (intmax_t) (new_plugin->pid));
1152
}
1153
1035
1154
/* Unblock SIGCHLD so signal handler can be run if this process
1036
1155
has already completed */
1037
1156
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1043
1162
goto fallback;
1044
1163
}
1045
1164
1046
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1047
-Wconversion */
1165
FD_SET(new_plugin->fd, &rfds_all);
1048
1166
1049
1167
if(maxfd < new_plugin->fd){
1050
1168
maxfd = new_plugin->fd;
1051
1169
}
1052
1170
}
1053
1171
1054
TEMP_FAILURE_RETRY(closedir(dir));
1055
dir = NULL;
1172
free(direntries);
1173
direntries = NULL;
1174
close(dir_fd);
1175
dir_fd = -1;
1056
1176
free_plugin(getplugin(NULL));
1057
1177
1058
1178
for(plugin *p = plugin_list; p != NULL; p = p->next){
1097
1217
(intmax_t) (proc->pid),
1098
1218
WTERMSIG(proc->status),
1099
1219
strsignal(WTERMSIG(proc->status)));
1100
} else if(WCOREDUMP(proc->status)){
1101
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1102
" core\n", proc->name, (intmax_t) (proc->pid));
1103
1220
}
1104
1221
}
1105
1222
1106
1223
/* Remove the plugin */
1107
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1108
-Wconversion */
1224
FD_CLR(proc->fd, &rfds_all);
1109
1225
1110
1226
/* Block signal while modifying process_list */
1111
1227
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1151
1267
}
1152
1268
1153
1269
/* This process has not completed. Does it have any output? */
1154
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1155
warning from
1156
-Wconversion */
1270
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1157
1271
/* This process had nothing to say at this time */
1158
1272
proc = proc->next;
1159
1273
continue;
1160
1274
}
1161
1275
/* Before reading, make the process' data buffer large enough */
1162
1276
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1163
proc->buffer = realloc(proc->buffer, proc->buffer_size
1164
+ (size_t) BUFFER_SIZE);
1165
if(proc->buffer == NULL){
1277
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1278
+ (size_t) BUFFER_SIZE);
1279
if(new_buffer == NULL){
1166
1280
error(0, errno, "malloc");
1167
1281
exitstatus = EX_OSERR;
1168
1282
goto fallback;
1169
1283
}
1284
proc->buffer = new_buffer;
1170
1285
proc->buffer_size += BUFFER_SIZE;
1171
1286
}
1172
1287
/* Read from the process */
1225
1340
free(custom_argv);
1226
1341
}
1227
1342
1228
if(dir != NULL){
1229
closedir(dir);
1343
free(direntries);
1344
1345
if(dir_fd != -1){
1346
close(dir_fd);
1230
1347
}
1231
1348
1232
1349
/* Kill the processes */
1252
1369
free_plugin_list();
1253
1370
1254
1371
free(plugindir);
1372
free(pluginhelperdir);
1255
1373
free(argfile);
1256
1374
1257
1375
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0