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 1229
- compare with another revision
- download diff
- download tarball
- view history from revision 1229
- Committer: teddy at recompile
- Date: 2020-12-03 20:30:45 UTC
- Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
- 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-2013 Teddy Hogeborn
6
* Copyright © 2008-2013 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-2020 Teddy Hogeborn
6
* Copyright © 2008-2020 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
26
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
26
asprintf(), O_CLOEXEC */
27
O_CLOEXEC, pipe2() */
27
28
#include <stddef.h> /* size_t, NULL */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_SUCCESS,
29
realloc() */
29
#include <stdlib.h> /* malloc(), reallocarray(), realloc(),
30
EXIT_SUCCESS, exit() */
30
31
#include <stdbool.h> /* bool, true, false */
31
32
#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() */
33
stderr, STDOUT_FILENO, fclose() */
34
#include <sys/types.h> /* fstat(), struct stat, waitpid(),
35
WIFEXITED(), WEXITSTATUS(), wait(),
36
pid_t, uid_t, gid_t, getuid(),
37
getgid() */
38
38
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
39
39
FD_SET(), FD_ISSET(), FD_CLR */
40
40
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
41
WEXITSTATUS(), WTERMSIG(),
42
WCOREDUMP() */
43
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
41
WEXITSTATUS(), WTERMSIG() */
42
#include <sys/stat.h> /* struct stat, fstat(), S_ISREG() */
44
43
#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() */
44
#include <dirent.h> /* struct dirent, scandirat() */
45
#include <unistd.h> /* fcntl(), F_GETFD, F_SETFD,
46
FD_CLOEXEC, write(), STDOUT_FILENO,
47
struct stat, fstat(), close(),
48
setgid(), setuid(), S_ISREG(),
49
faccessat() pipe2(), fork(),
50
_exit(), dup2(), fexecve(), read()
51
*/
54
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
55
FD_CLOEXEC */
56
#include <string.h> /* strsep, strlen(), asprintf(),
57
strsignal(), strcmp(), strncmp() */
53
FD_CLOEXEC, openat(), scandirat(),
54
pipe2() */
55
#include <string.h> /* strsep, strlen(), strsignal(),
56
strcmp(), strncmp() */
58
57
#include <errno.h> /* errno */
59
58
#include <argp.h> /* struct argp_option, struct
60
59
argp_state, struct argp,
72
71
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
72
#include <errno.h> /* errno */
74
73
#include <error.h> /* error() */
74
#include <fnmatch.h> /* fnmatch() */
75
75
76
76
#define BUFFER_SIZE 256
77
77
78
78
#define PDIR "/lib/mandos/plugins.d"
79
#define PHDIR "/lib/mandos/plugin-helpers"
79
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
81
81
82
const char *argp_program_version = "plugin-runner " VERSION;
105
106
106
107
/* Gets an existing plugin based on name,
107
108
or if none is found, creates a new one */
109
__attribute__((warn_unused_result))
108
110
static plugin *getplugin(char *name){
109
111
/* Check for existing plugin with that name */
110
112
for(plugin *p = plugin_list; p != NULL; p = p->next){
171
173
}
172
174
173
175
/* Helper function for add_argument and add_environment */
174
__attribute__((nonnull))
176
__attribute__((nonnull, warn_unused_result))
175
177
static bool add_to_char_array(const char *new, char ***array,
176
178
int *len){
177
179
/* Resize the pointed-to array to hold one more pointer */
180
char **new_array = NULL;
178
181
do {
179
*array = realloc(*array, sizeof(char *)
180
* (size_t) ((*len) + 2));
181
} while(*array == NULL and errno == EINTR);
182
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
183
new_array = reallocarray(*array, (size_t)((*len) + 2),
184
sizeof(char *));
185
#else
186
if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
187
/* overflow */
188
new_array = NULL;
189
errno = ENOMEM;
190
} else {
191
new_array = realloc(*array, (size_t)((*len) + 2)
192
* sizeof(char *));
193
}
194
#endif
195
} while(new_array == NULL and errno == EINTR);
182
196
/* Malloc check */
183
if(*array == NULL){
197
if(new_array == NULL){
184
198
return false;
185
199
}
200
*array = new_array;
186
201
/* Make a copy of the new string */
187
202
char *copy;
188
203
do {
200
215
}
201
216
202
217
/* Add to a plugin's argument vector */
203
__attribute__((nonnull(2)))
218
__attribute__((nonnull(2), warn_unused_result))
204
219
static bool add_argument(plugin *p, const char *arg){
205
220
if(p == NULL){
206
221
return false;
209
224
}
210
225
211
226
/* Add to a plugin's environment */
212
__attribute__((nonnull(2)))
227
__attribute__((nonnull(2), warn_unused_result))
213
228
static bool add_environment(plugin *p, const char *def, bool replace){
214
229
if(p == NULL){
215
230
return false;
217
232
/* namelen = length of name of environment variable */
218
233
size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
234
/* Search for this environment variable */
220
for(char **e = p->environ; *e != NULL; e++){
221
if(strncmp(*e, def, namelen + 1) == 0){
235
for(char **envdef = p->environ; *envdef != NULL; envdef++){
236
if(strncmp(*envdef, def, namelen + 1) == 0){
222
237
/* It already exists */
223
238
if(replace){
224
char *new;
239
char *new_envdef;
225
240
do {
226
new = realloc(*e, strlen(def) + 1);
227
} while(new == NULL and errno == EINTR);
228
if(new == NULL){
241
new_envdef = realloc(*envdef, strlen(def) + 1);
242
} while(new_envdef == NULL and errno == EINTR);
243
if(new_envdef == NULL){
229
244
return false;
230
245
}
231
*e = new;
232
strcpy(*e, def);
246
*envdef = new_envdef;
247
strcpy(*envdef, def);
233
248
}
234
249
return true;
235
250
}
237
252
return add_to_char_array(def, &(p->environ), &(p->envc));
238
253
}
239
254
255
#ifndef O_CLOEXEC
240
256
/*
241
257
* Based on the example in the GNU LibC manual chapter 13.13 "File
242
258
* Descriptor Flags".
243
259
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
244
260
*/
261
__attribute__((warn_unused_result))
245
262
static int set_cloexec_flag(int fd){
246
263
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
247
264
/* If reading the flags failed, return error indication now. */
252
269
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
270
ret | FD_CLOEXEC));
254
271
}
272
#endif /* not O_CLOEXEC */
255
273
256
274
257
275
/* Mark processes as completed when they exit, and save their exit
289
307
}
290
308
291
309
/* Prints out a password to stdout */
292
__attribute__((nonnull))
310
__attribute__((nonnull, warn_unused_result))
293
311
static bool print_out_password(const char *buffer, size_t length){
294
312
ssize_t ret;
295
313
for(size_t written = 0; written < length; written += (size_t)ret){
306
324
__attribute__((nonnull))
307
325
static void free_plugin(plugin *plugin_node){
308
326
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
327
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
310
328
free(*arg);
311
329
}
330
free(plugin_node->name);
312
331
free(plugin_node->argv);
313
332
for(char **env = plugin_node->environ; *env != NULL; env++){
314
333
free(*env);
341
360
342
361
int main(int argc, char *argv[]){
343
362
char *plugindir = NULL;
363
char *pluginhelperdir = NULL;
344
364
char *argfile = NULL;
345
365
FILE *conffp;
346
size_t d_name_len;
347
DIR *dir = NULL;
348
struct dirent *dirst;
366
struct dirent **direntries = NULL;
349
367
struct stat st;
350
368
fd_set rfds_all;
351
369
int ret, maxfd = 0;
359
377
.sa_flags = SA_NOCLDSTOP };
360
378
char **custom_argv = NULL;
361
379
int custom_argc = 0;
380
int dir_fd = -1;
362
381
363
382
/* Establish a signal handler */
364
383
sigemptyset(&sigchld_action.sa_mask);
409
428
.doc = "Group ID the plugins will run as", .group = 3 },
410
429
{ .name = "debug", .key = 132,
411
430
.doc = "Debug mode", .group = 4 },
431
{ .name = "plugin-helper-dir", .key = 133,
432
.arg = "DIRECTORY",
433
.doc = "Specify a different plugin helper directory",
434
.group = 2 },
412
435
/*
413
436
* These reproduce what we would get without ARGP_NO_HELP
414
437
*/
435
458
break;
436
459
}
437
460
}
461
errno = 0;
438
462
}
439
463
break;
440
464
case 'G': /* --global-env */
441
add_environment(getplugin(NULL), arg, true);
465
if(add_environment(getplugin(NULL), arg, true)){
466
errno = 0;
467
}
442
468
break;
443
469
case 'o': /* --options-for */
444
470
{
461
487
break;
462
488
}
463
489
}
490
errno = 0;
464
491
}
465
492
break;
466
493
case 'E': /* --env-for */
478
505
errno = EINVAL;
479
506
break;
480
507
}
481
add_environment(getplugin(arg), envdef, true);
508
if(add_environment(getplugin(arg), envdef, true)){
509
errno = 0;
510
}
482
511
}
483
512
break;
484
513
case 'd': /* --disable */
486
515
plugin *p = getplugin(arg);
487
516
if(p != NULL){
488
517
p->disabled = true;
518
errno = 0;
489
519
}
490
520
}
491
521
break;
494
524
plugin *p = getplugin(arg);
495
525
if(p != NULL){
496
526
p->disabled = false;
527
errno = 0;
497
528
}
498
529
}
499
530
break;
500
531
case 128: /* --plugin-dir */
501
532
free(plugindir);
502
533
plugindir = strdup(arg);
534
if(plugindir != NULL){
535
errno = 0;
536
}
503
537
break;
504
538
case 129: /* --config-file */
505
539
/* This is already done by parse_opt_config_file() */
513
547
break;
514
548
}
515
549
uid = (uid_t)tmp_id;
550
errno = 0;
516
551
break;
517
552
case 131: /* --groupid */
518
553
tmp_id = strtoimax(arg, &tmp, 10);
523
558
break;
524
559
}
525
560
gid = (gid_t)tmp_id;
561
errno = 0;
526
562
break;
527
563
case 132: /* --debug */
528
564
debug = true;
529
565
break;
566
case 133: /* --plugin-helper-dir */
567
free(pluginhelperdir);
568
pluginhelperdir = strdup(arg);
569
if(pluginhelperdir != NULL){
570
errno = 0;
571
}
572
break;
530
573
/*
531
574
* These reproduce what we would get without ARGP_NO_HELP
532
575
*/
533
576
case '?': /* --help */
534
577
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
535
578
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
579
__builtin_unreachable();
536
580
case -3: /* --usage */
537
581
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
538
582
argp_state_help(state, state->out_stream,
539
583
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
584
__builtin_unreachable();
540
585
case 'V': /* --version */
541
586
fprintf(state->out_stream, "%s\n", argp_program_version);
542
587
exit(EXIT_SUCCESS);
552
597
if(arg[0] == '\0'){
553
598
break;
554
599
}
600
#if __GNUC__ >= 7
601
__attribute__((fallthrough));
602
#else
603
/* FALLTHROUGH */
604
#endif
555
605
default:
556
606
return ARGP_ERR_UNKNOWN;
557
607
}
576
626
case 129: /* --config-file */
577
627
free(argfile);
578
628
argfile = strdup(arg);
629
if(argfile != NULL){
630
errno = 0;
631
}
579
632
break;
580
633
case 130: /* --userid */
581
634
case 131: /* --groupid */
582
635
case 132: /* --debug */
636
case 133: /* --plugin-helper-dir */
583
637
case '?': /* --help */
584
638
case -3: /* --usage */
585
639
case 'V': /* --version */
664
718
}
665
719
666
720
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;
721
{
722
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
723
char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
724
sizeof(char *));
725
#else
726
char **new_argv = NULL;
727
if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
728
/* overflow */
729
errno = ENOMEM;
730
} else {
731
new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
732
* sizeof(char *));
733
}
734
#endif
735
if(new_argv == NULL){
736
error(0, errno, "reallocarray");
737
exitstatus = EX_OSERR;
738
free(new_arg);
739
free(org_line);
740
goto fallback;
741
} else {
742
custom_argv = new_argv;
743
}
674
744
}
675
745
custom_argv[custom_argc-1] = new_arg;
676
746
custom_argv[custom_argc] = NULL;
734
804
goto fallback;
735
805
}
736
806
807
{
808
char *pluginhelperenv;
809
bool bret = true;
810
ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
811
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
812
if(ret != -1){
813
bret = add_environment(getplugin(NULL), pluginhelperenv, true);
814
}
815
if(ret == -1 or not bret){
816
error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
817
" environment variable to \"%s\" for all plugins\n",
818
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
819
}
820
if(ret != -1){
821
free(pluginhelperenv);
822
}
823
}
824
737
825
if(debug){
738
for(plugin *p = plugin_list; p != NULL; p=p->next){
826
for(plugin *p = plugin_list; p != NULL; p = p->next){
739
827
fprintf(stderr, "Plugin: %s has %d arguments\n",
740
828
p->name ? p->name : "Global", p->argc - 1);
741
829
for(char **a = p->argv; *a != NULL; a++){
750
838
751
839
if(getuid() == 0){
752
840
/* Work around Debian bug #633582:
753
<http://bugs.debian.org/633582> */
841
<https://bugs.debian.org/633582> */
754
842
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
755
843
if(plugindir_fd == -1){
756
error(0, errno, "open");
844
if(errno != ENOENT){
845
error(0, errno, "open(\"" PDIR "\")");
846
}
757
847
} else {
758
848
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
759
849
if(ret == -1){
766
856
}
767
857
}
768
858
}
769
TEMP_FAILURE_RETRY(close(plugindir_fd));
859
close(plugindir_fd);
770
860
}
771
861
}
772
862
782
872
783
873
/* Open plugin directory with close_on_exec flag */
784
874
{
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
}
875
dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
876
#ifdef O_CLOEXEC
877
O_CLOEXEC
878
#else /* not O_CLOEXEC */
879
0
880
#endif /* not O_CLOEXEC */
881
);
803
882
if(dir_fd == -1){
804
883
error(0, errno, "Could not open plugin dir");
805
884
exitstatus = EX_UNAVAILABLE;
811
890
ret = set_cloexec_flag(dir_fd);
812
891
if(ret < 0){
813
892
error(0, errno, "set_cloexec_flag");
814
TEMP_FAILURE_RETRY(close(dir_fd));
815
893
exitstatus = EX_OSERR;
816
894
goto fallback;
817
895
}
818
896
#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;
897
}
898
899
int good_name(const struct dirent * const dirent){
900
const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
901
"*.dpkg-old", "*.dpkg-bak",
902
"*.dpkg-divert", NULL };
903
#ifdef __GNUC__
904
#pragma GCC diagnostic push
905
#pragma GCC diagnostic ignored "-Wcast-qual"
906
#endif
907
for(const char **pat = (const char **)patterns;
908
*pat != NULL; pat++){
909
#ifdef __GNUC__
910
#pragma GCC diagnostic pop
911
#endif
912
if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
913
!= FNM_NOMATCH){
914
if(debug){
915
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
916
" matching pattern %s\n", dirent->d_name, *pat);
917
}
918
return 0;
919
}
826
920
}
921
return 1;
922
}
923
924
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
925
alphasort);
926
if(numplugins == -1){
927
error(0, errno, "Could not scan plugin dir");
928
direntries = NULL;
929
exitstatus = EX_OSERR;
930
goto fallback;
827
931
}
828
932
829
933
FD_ZERO(&rfds_all);
830
934
831
935
/* 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");
936
for(int i = 0; i < numplugins; i++){
937
938
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
939
if(plugin_fd == -1){
940
error(0, errno, "Could not open plugin");
941
free(direntries[i]);
904
942
continue;
905
943
}
906
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
944
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
908
945
if(ret == -1){
909
946
error(0, errno, "stat");
910
free(filename);
947
close(plugin_fd);
948
free(direntries[i]);
911
949
continue;
912
950
}
913
951
914
952
/* Ignore non-executable files */
915
953
if(not S_ISREG(st.st_mode)
916
or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
954
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
955
X_OK, 0)) != 0)){
917
956
if(debug){
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
919
" with bad type or mode\n", filename);
957
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
958
" with bad type or mode\n",
959
plugindir != NULL ? plugindir : PDIR,
960
direntries[i]->d_name);
920
961
}
921
free(filename);
962
close(plugin_fd);
963
free(direntries[i]);
922
964
continue;
923
965
}
924
966
925
plugin *p = getplugin(dirst->d_name);
967
plugin *p = getplugin(direntries[i]->d_name);
926
968
if(p == NULL){
927
969
error(0, errno, "getplugin");
928
free(filename);
970
close(plugin_fd);
971
free(direntries[i]);
929
972
continue;
930
973
}
931
974
if(p->disabled){
932
975
if(debug){
933
976
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
934
dirst->d_name);
977
direntries[i]->d_name);
935
978
}
936
free(filename);
979
close(plugin_fd);
980
free(direntries[i]);
937
981
continue;
938
982
}
939
983
{
953
997
}
954
998
}
955
999
}
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. */
1000
/* If this plugin has any environment variables, we need to
1001
duplicate the environment from this process, too. */
959
1002
if(p->environ[0] != NULL){
960
1003
for(char **e = environ; *e != NULL; e++){
961
1004
if(not add_environment(p, *e, false)){
965
1008
}
966
1009
967
1010
int pipefd[2];
1011
#ifndef O_CLOEXEC
968
1012
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
1013
#else /* O_CLOEXEC */
1014
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
1015
#endif /* O_CLOEXEC */
969
1016
if(ret == -1){
970
1017
error(0, errno, "pipe");
971
1018
exitstatus = EX_OSERR;
972
goto fallback;
973
}
1019
free(direntries[i]);
1020
goto fallback;
1021
}
1022
if(pipefd[0] >= FD_SETSIZE){
1023
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1024
FD_SETSIZE);
1025
close(pipefd[0]);
1026
close(pipefd[1]);
1027
exitstatus = EX_OSERR;
1028
free(direntries[i]);
1029
goto fallback;
1030
}
1031
#ifndef O_CLOEXEC
974
1032
/* Ask OS to automatic close the pipe on exec */
975
1033
ret = set_cloexec_flag(pipefd[0]);
976
1034
if(ret < 0){
977
1035
error(0, errno, "set_cloexec_flag");
1036
close(pipefd[0]);
1037
close(pipefd[1]);
978
1038
exitstatus = EX_OSERR;
1039
free(direntries[i]);
979
1040
goto fallback;
980
1041
}
981
1042
ret = set_cloexec_flag(pipefd[1]);
982
1043
if(ret < 0){
983
1044
error(0, errno, "set_cloexec_flag");
1045
close(pipefd[0]);
1046
close(pipefd[1]);
984
1047
exitstatus = EX_OSERR;
1048
free(direntries[i]);
985
1049
goto fallback;
986
1050
}
1051
#endif /* not O_CLOEXEC */
987
1052
/* Block SIGCHLD until process is safely in process list */
988
1053
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
989
1054
&sigchld_action.sa_mask,
991
1056
if(ret < 0){
992
1057
error(0, errno, "sigprocmask");
993
1058
exitstatus = EX_OSERR;
1059
free(direntries[i]);
994
1060
goto fallback;
995
1061
}
996
1062
/* Starting a new process to be watched */
1000
1066
} while(pid == -1 and errno == EINTR);
1001
1067
if(pid == -1){
1002
1068
error(0, errno, "fork");
1069
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1070
&sigchld_action.sa_mask, NULL));
1071
close(pipefd[0]);
1072
close(pipefd[1]);
1003
1073
exitstatus = EX_OSERR;
1074
free(direntries[i]);
1004
1075
goto fallback;
1005
1076
}
1006
1077
if(pid == 0){
1022
1093
_exit(EX_OSERR);
1023
1094
}
1024
1095
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
}
1096
if(fexecve(plugin_fd, p->argv,
1097
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1098
error(0, errno, "fexecve for %s/%s",
1099
plugindir != NULL ? plugindir : PDIR,
1100
direntries[i]->d_name);
1101
_exit(EX_OSERR);
1040
1102
}
1041
1103
/* no return */
1042
1104
}
1043
1105
/* 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);
1106
close(pipefd[1]); /* Close unused write end of pipe */
1107
close(plugin_fd);
1108
plugin *new_plugin = getplugin(direntries[i]->d_name);
1048
1109
if(new_plugin == NULL){
1049
1110
error(0, errno, "getplugin");
1050
1111
ret = (int)(TEMP_FAILURE_RETRY
1054
1115
error(0, errno, "sigprocmask");
1055
1116
}
1056
1117
exitstatus = EX_OSERR;
1118
free(direntries[i]);
1057
1119
goto fallback;
1058
1120
}
1121
free(direntries[i]);
1059
1122
1060
1123
new_plugin->pid = pid;
1061
1124
new_plugin->fd = pipefd[0];
1062
1125
1126
if(debug){
1127
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1128
new_plugin->name, (intmax_t) (new_plugin->pid));
1129
}
1130
1063
1131
/* Unblock SIGCHLD so signal handler can be run if this process
1064
1132
has already completed */
1065
1133
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1071
1139
goto fallback;
1072
1140
}
1073
1141
1074
#if defined (__GNUC__) and defined (__GLIBC__)
1075
#if not __GLIBC_PREREQ(2, 16)
1076
#pragma GCC diagnostic push
1077
#pragma GCC diagnostic ignored "-Wsign-conversion"
1078
#endif
1079
#endif
1080
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1081
-Wconversion in GNU libc
1082
before 2.16 */
1083
#if defined (__GNUC__) and defined (__GLIBC__)
1084
#if not __GLIBC_PREREQ(2, 16)
1085
#pragma GCC diagnostic pop
1086
#endif
1087
#endif
1142
FD_SET(new_plugin->fd, &rfds_all);
1088
1143
1089
1144
if(maxfd < new_plugin->fd){
1090
1145
maxfd = new_plugin->fd;
1091
1146
}
1092
1147
}
1093
1148
1094
TEMP_FAILURE_RETRY(closedir(dir));
1095
dir = NULL;
1149
free(direntries);
1150
direntries = NULL;
1151
close(dir_fd);
1152
dir_fd = -1;
1096
1153
free_plugin(getplugin(NULL));
1097
1154
1098
1155
for(plugin *p = plugin_list; p != NULL; p = p->next){
1137
1194
(intmax_t) (proc->pid),
1138
1195
WTERMSIG(proc->status),
1139
1196
strsignal(WTERMSIG(proc->status)));
1140
} else if(WCOREDUMP(proc->status)){
1141
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1142
" core\n", proc->name, (intmax_t) (proc->pid));
1143
1197
}
1144
1198
}
1145
1199
1146
1200
/* Remove the plugin */
1147
#if defined (__GNUC__) and defined (__GLIBC__)
1148
#if not __GLIBC_PREREQ(2, 16)
1149
#pragma GCC diagnostic push
1150
#pragma GCC diagnostic ignored "-Wsign-conversion"
1151
#endif
1152
#endif
1153
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1154
-Wconversion in GNU libc
1155
before 2.16 */
1156
#if defined (__GNUC__) and defined (__GLIBC__)
1157
#if not __GLIBC_PREREQ(2, 16)
1158
#pragma GCC diagnostic pop
1159
#endif
1160
#endif
1201
FD_CLR(proc->fd, &rfds_all);
1161
1202
1162
1203
/* Block signal while modifying process_list */
1163
1204
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1203
1244
}
1204
1245
1205
1246
/* This process has not completed. Does it have any output? */
1206
#if defined (__GNUC__) and defined (__GLIBC__)
1207
#if not __GLIBC_PREREQ(2, 16)
1208
#pragma GCC diagnostic push
1209
#pragma GCC diagnostic ignored "-Wsign-conversion"
1210
#endif
1211
#endif
1212
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1213
warning from
1214
-Wconversion
1215
in GNU libc
1216
before
1217
2.16 */
1218
#if defined (__GNUC__) and defined (__GLIBC__)
1219
#if not __GLIBC_PREREQ(2, 16)
1220
#pragma GCC diagnostic pop
1221
#endif
1222
#endif
1247
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1223
1248
/* This process had nothing to say at this time */
1224
1249
proc = proc->next;
1225
1250
continue;
1226
1251
}
1227
1252
/* Before reading, make the process' data buffer large enough */
1228
1253
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1229
proc->buffer = realloc(proc->buffer, proc->buffer_size
1230
+ (size_t) BUFFER_SIZE);
1231
if(proc->buffer == NULL){
1254
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1255
+ (size_t) BUFFER_SIZE);
1256
if(new_buffer == NULL){
1232
1257
error(0, errno, "malloc");
1233
1258
exitstatus = EX_OSERR;
1234
1259
goto fallback;
1235
1260
}
1261
proc->buffer = new_buffer;
1236
1262
proc->buffer_size += BUFFER_SIZE;
1237
1263
}
1238
1264
/* Read from the process */
1291
1317
free(custom_argv);
1292
1318
}
1293
1319
1294
if(dir != NULL){
1295
closedir(dir);
1320
free(direntries);
1321
1322
if(dir_fd != -1){
1323
close(dir_fd);
1296
1324
}
1297
1325
1298
1326
/* Kill the processes */
1318
1346
free_plugin_list();
1319
1347
1320
1348
free(plugindir);
1349
free(pluginhelperdir);
1321
1350
free(argfile);
1322
1351
1323
1352
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0