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:
- DBUS-API
- debian/source
- debian/tests
- debian/upstream
- dracut-module
- network-hooks.d
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
plugin-runner.c
1
/* -*- coding: utf-8 -*- */
1
/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
3
* Mandos plugin runner - Run Mandos plugins
4
4
*
5
* Copyright © 2008,2009 Teddy Hogeborn
6
* Copyright © 2008,2009 Björn Påhlsson
7
*
8
* This program is free software: you can redistribute it and/or
9
* modify it under the terms of the GNU General Public License as
10
* published by the Free Software Foundation, either version 3 of the
11
* License, or (at your option) any later version.
12
*
13
* This program is distributed in the hope that it will be useful, but
5
* Copyright © 2008-2021 Teddy Hogeborn
6
* Copyright © 2008-2021 Björn Påhlsson
7
*
8
* This file is part of Mandos.
9
*
10
* Mandos is free software: you can redistribute it and/or modify it
11
* under the terms of the GNU General Public License as published by
12
* the Free Software Foundation, either version 3 of the License, or
13
* (at your option) any later version.
14
*
15
* Mandos is distributed in the hope that it will be useful, but
14
16
* WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
18
* General Public License for more details.
17
19
*
18
20
* You should have received a copy of the GNU General Public License
19
* along with this program. If not, see
20
* <http://www.gnu.org/licenses/>.
21
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
21
22
*
22
* Contact the authors at <mandos@fukt.bsnet.se>.
23
* Contact the authors at <mandos@recompile.se>.
23
24
*/
24
25
25
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
26
asprintf() */
26
#define _GNU_SOURCE /* strchrnul(), TEMP_FAILURE_RETRY(),
27
getline(), asprintf(), O_CLOEXEC,
28
scandirat(), pipe2() */
29
#include <argp.h> /* argp_program_version,
30
argp_program_bug_address,
31
struct argp_option,
32
struct argp_state, argp_error(),
33
ARGP_NO_EXIT, argp_state_help,
34
ARGP_HELP_STD_HELP,
35
ARGP_HELP_USAGE, ARGP_HELP_EXIT_OK,
36
ARGP_KEY_ARG, ARGP_ERR_UNKNOWN,
37
struct argp, argp_parse(),
38
ARGP_IN_ORDER, ARGP_NO_HELP */
39
#include <stdbool.h> /* bool, false, true */
40
#include <sys/types.h> /* pid_t, sig_atomic_t, uid_t, gid_t,
41
getuid(), setgid(), setuid() */
27
42
#include <stddef.h> /* size_t, NULL */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
29
EXIT_SUCCESS, realloc() */
30
#include <stdbool.h> /* bool, true, false */
31
#include <stdio.h> /* perror, fileno(), fprintf(),
32
stderr, STDOUT_FILENO */
33
#include <sys/types.h> /* DIR, opendir(), 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() */
42
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
43
#include <iso646.h> /* and, or, not */
44
#include <dirent.h> /* DIR, struct dirent, opendir(),
45
readdir(), closedir(), dirfd() */
46
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
47
fcntl(), setuid(), setgid(),
48
F_GETFD, F_SETFD, FD_CLOEXEC,
49
access(), pipe(), fork(), close()
50
dup2(), STDOUT_FILENO, _exit(),
51
execv(), write(), read(),
52
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() */
53
63
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
54
FD_CLOEXEC */
55
#include <string.h> /* strsep, strlen(), asprintf() */
56
#include <errno.h> /* errno */
57
#include <argp.h> /* struct argp_option, struct
58
argp_state, struct argp,
59
argp_parse(), ARGP_ERR_UNKNOWN,
60
ARGP_KEY_END, ARGP_KEY_ARG,
61
error_t */
62
#include <signal.h> /* struct sigaction, sigemptyset(),
63
sigaddset(), sigaction(),
64
sigprocmask(), SIG_BLOCK, SIGCHLD,
65
SIG_UNBLOCK, kill() */
66
#include <errno.h> /* errno, EBADF */
67
#include <inttypes.h> /* intmax_t, SCNdMAX, PRIdMAX, */
64
FD_CLOEXEC, open(), O_RDONLY,
65
O_CLOEXEC, openat() */
66
#include <sys/wait.h> /* waitpid(), WNOHANG, WIFEXITED(),
67
WEXITSTATUS(), WIFSIGNALED(),
68
WTERMSIG(), wait() */
69
#include <error.h> /* error() */
70
#include <stdio.h> /* FILE, fprintf(), fopen(),
71
getline(), fclose(), EOF,
72
asprintf(), stderr */
73
#include <dirent.h> /* struct dirent, scandirat(),
74
alphasort() */
75
#include <sys/stat.h> /* struct stat, fstat(), S_ISDIR(),
76
lstat(), S_ISREG() */
77
#include <sys/select.h> /* fd_set, FD_ZERO(), FD_SETSIZE,
78
FD_SET(), select(), FD_CLR(),
79
FD_ISSET() */
80
#include <signal.h> /* struct sigaction, SA_NOCLDSTOP,
81
sigemptyset(), sigaddset(),
82
SIGCHLD, sigprocmask(), SIG_BLOCK,
83
SIG_UNBLOCK, kill(), SIGTERM */
84
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,
85
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
86
#include <inttypes.h> /* intmax_t, strtoimax(), PRIdMAX */
87
#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME,
88
FNM_PERIOD, FNM_NOMATCH */
68
89
69
90
#define BUFFER_SIZE 256
70
91
71
92
#define PDIR "/lib/mandos/plugins.d"
93
#define PHDIR "/lib/mandos/plugin-helpers"
72
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
73
95
74
96
const char *argp_program_version = "plugin-runner " VERSION;
75
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
76
98
77
99
typedef struct plugin{
78
100
char *name; /* can be NULL or any plugin name */
81
103
char **environ;
82
104
int envc;
83
105
bool disabled;
84
106
85
107
/* Variables used for running processes*/
86
108
pid_t pid;
87
109
int fd;
98
120
99
121
/* Gets an existing plugin based on name,
100
122
or if none is found, creates a new one */
123
__attribute__((warn_unused_result))
101
124
static plugin *getplugin(char *name){
102
/* Check for exiting plugin with that name */
125
/* Check for existing plugin with that name */
103
126
for(plugin *p = plugin_list; p != NULL; p = p->next){
104
127
if((p->name == name)
105
128
or (p->name and name and (strcmp(p->name, name) == 0))){
107
130
}
108
131
}
109
132
/* Create a new plugin */
110
plugin *new_plugin = malloc(sizeof(plugin));
133
plugin *new_plugin = NULL;
134
do {
135
new_plugin = malloc(sizeof(plugin));
136
} while(new_plugin == NULL and errno == EINTR);
111
137
if(new_plugin == NULL){
112
138
return NULL;
113
139
}
114
140
char *copy_name = NULL;
115
141
if(name != NULL){
116
copy_name = strdup(name);
142
do {
143
copy_name = strdup(name);
144
} while(copy_name == NULL and errno == EINTR);
117
145
if(copy_name == NULL){
146
int e = errno;
118
147
free(new_plugin);
148
errno = e;
119
149
return NULL;
120
150
}
121
151
}
125
155
.disabled = false,
126
156
.next = plugin_list };
127
157
128
new_plugin->argv = malloc(sizeof(char *) * 2);
158
do {
159
new_plugin->argv = malloc(sizeof(char *) * 2);
160
} while(new_plugin->argv == NULL and errno == EINTR);
129
161
if(new_plugin->argv == NULL){
162
int e = errno;
130
163
free(copy_name);
131
164
free(new_plugin);
165
errno = e;
132
166
return NULL;
133
167
}
134
168
new_plugin->argv[0] = copy_name;
135
169
new_plugin->argv[1] = NULL;
136
170
137
new_plugin->environ = malloc(sizeof(char *));
171
do {
172
new_plugin->environ = malloc(sizeof(char *));
173
} while(new_plugin->environ == NULL and errno == EINTR);
138
174
if(new_plugin->environ == NULL){
175
int e = errno;
139
176
free(copy_name);
140
177
free(new_plugin->argv);
141
178
free(new_plugin);
179
errno = e;
142
180
return NULL;
143
181
}
144
182
new_plugin->environ[0] = NULL;
149
187
}
150
188
151
189
/* Helper function for add_argument and add_environment */
190
__attribute__((nonnull, warn_unused_result))
152
191
static bool add_to_char_array(const char *new, char ***array,
153
192
int *len){
154
193
/* Resize the pointed-to array to hold one more pointer */
155
*array = realloc(*array, sizeof(char *)
156
* (size_t) ((*len) + 2));
194
char **new_array = NULL;
195
do {
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);
157
210
/* Malloc check */
158
if(*array == NULL){
211
if(new_array == NULL){
159
212
return false;
160
213
}
214
*array = new_array;
161
215
/* Make a copy of the new string */
162
char *copy = strdup(new);
216
char *copy;
217
do {
218
copy = strdup(new);
219
} while(copy == NULL and errno == EINTR);
163
220
if(copy == NULL){
164
221
return false;
165
222
}
172
229
}
173
230
174
231
/* Add to a plugin's argument vector */
232
__attribute__((nonnull(2), warn_unused_result))
175
233
static bool add_argument(plugin *p, const char *arg){
176
234
if(p == NULL){
177
235
return false;
180
238
}
181
239
182
240
/* Add to a plugin's environment */
241
__attribute__((nonnull(2), warn_unused_result))
183
242
static bool add_environment(plugin *p, const char *def, bool replace){
184
243
if(p == NULL){
185
244
return false;
187
246
/* namelen = length of name of environment variable */
188
247
size_t namelen = (size_t)(strchrnul(def, '=') - def);
189
248
/* Search for this environment variable */
190
for(char **e = p->environ; *e != NULL; e++){
191
if(strncmp(*e, def, namelen + 1) == 0){
249
for(char **envdef = p->environ; *envdef != NULL; envdef++){
250
if(strncmp(*envdef, def, namelen + 1) == 0){
192
251
/* It already exists */
193
252
if(replace){
194
char *new = realloc(*e, strlen(def) + 1);
195
if(new == NULL){
253
char *new_envdef;
254
do {
255
new_envdef = realloc(*envdef, strlen(def) + 1);
256
} while(new_envdef == NULL and errno == EINTR);
257
if(new_envdef == NULL){
196
258
return false;
197
259
}
198
*e = new;
199
strcpy(*e, def);
260
*envdef = new_envdef;
261
strcpy(*envdef, def);
200
262
}
201
263
return true;
202
264
}
204
266
return add_to_char_array(def, &(p->environ), &(p->envc));
205
267
}
206
268
269
#ifndef O_CLOEXEC
207
270
/*
208
271
* Based on the example in the GNU LibC manual chapter 13.13 "File
209
272
* Descriptor Flags".
210
* *Note File Descriptor Flags:(libc)Descriptor Flags.
273
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
211
274
*/
275
__attribute__((warn_unused_result))
212
276
static int set_cloexec_flag(int fd){
213
int ret = fcntl(fd, F_GETFD, 0);
277
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
214
278
/* If reading the flags failed, return error indication now. */
215
279
if(ret < 0){
216
280
return ret;
217
281
}
218
282
/* Store modified flag word in the descriptor. */
219
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
283
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
284
ret | FD_CLOEXEC));
220
285
}
286
#endif /* not O_CLOEXEC */
221
287
222
288
223
289
/* Mark processes as completed when they exit, and save their exit
237
303
/* No child processes */
238
304
break;
239
305
}
240
perror("waitpid");
306
error(0, errno, "waitpid");
241
307
}
242
308
243
309
/* A child exited, find it in process_list */
255
321
}
256
322
257
323
/* Prints out a password to stdout */
324
__attribute__((nonnull, warn_unused_result))
258
325
static bool print_out_password(const char *buffer, size_t length){
259
326
ssize_t ret;
260
327
for(size_t written = 0; written < length; written += (size_t)ret){
268
335
}
269
336
270
337
/* Removes and free a plugin from the plugin list */
338
__attribute__((nonnull))
271
339
static void free_plugin(plugin *plugin_node){
272
340
273
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
341
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
274
342
free(*arg);
275
343
}
344
free(plugin_node->name);
276
345
free(plugin_node->argv);
277
346
for(char **env = plugin_node->environ; *env != NULL; env++){
278
347
free(*env);
279
348
}
280
349
free(plugin_node->environ);
281
350
free(plugin_node->buffer);
282
351
283
352
/* Removes the plugin from the singly-linked list */
284
353
if(plugin_node == plugin_list){
285
354
/* First one - simple */
305
374
306
375
int main(int argc, char *argv[]){
307
376
char *plugindir = NULL;
377
char *pluginhelperdir = NULL;
308
378
char *argfile = NULL;
309
379
FILE *conffp;
310
size_t d_name_len;
311
DIR *dir = NULL;
312
struct dirent *dirst;
380
struct dirent **direntries = NULL;
313
381
struct stat st;
314
382
fd_set rfds_all;
315
int ret, numchars, maxfd = 0;
383
int ret, maxfd = 0;
316
384
ssize_t sret;
317
intmax_t tmpmax;
318
385
uid_t uid = 65534;
319
386
gid_t gid = 65534;
320
387
bool debug = false;
324
391
.sa_flags = SA_NOCLDSTOP };
325
392
char **custom_argv = NULL;
326
393
int custom_argc = 0;
394
int dir_fd = -1;
327
395
328
396
/* Establish a signal handler */
329
397
sigemptyset(&sigchld_action.sa_mask);
330
398
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
331
399
if(ret == -1){
332
perror("sigaddset");
333
exitstatus = EXIT_FAILURE;
400
error(0, errno, "sigaddset");
401
exitstatus = EX_OSERR;
334
402
goto fallback;
335
403
}
336
404
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
337
405
if(ret == -1){
338
perror("sigaction");
339
exitstatus = EXIT_FAILURE;
406
error(0, errno, "sigaction");
407
exitstatus = EX_OSERR;
340
408
goto fallback;
341
409
}
342
410
374
442
.doc = "Group ID the plugins will run as", .group = 3 },
375
443
{ .name = "debug", .key = 132,
376
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 },
449
/*
450
* These reproduce what we would get without ARGP_NO_HELP
451
*/
452
{ .name = "help", .key = '?',
453
.doc = "Give this help list", .group = -1 },
454
{ .name = "usage", .key = -3,
455
.doc = "Give a short usage message", .group = -1 },
456
{ .name = "version", .key = 'V',
457
.doc = "Print program version", .group = -1 },
377
458
{ .name = NULL }
378
459
};
379
460
380
error_t parse_opt(int key, char *arg, __attribute__((unused))
381
struct argp_state *state){
461
__attribute__((nonnull(3)))
462
error_t parse_opt(int key, char *arg, struct argp_state *state){
463
errno = 0;
382
464
switch(key){
465
char *tmp;
466
intmax_t tmp_id;
383
467
case 'g': /* --global-options */
384
if(arg != NULL){
385
char *p;
386
while((p = strsep(&arg, ",")) != NULL){
387
if(p[0] == '\0'){
388
continue;
389
}
390
if(not add_argument(getplugin(NULL), p)){
391
perror("add_argument");
392
return ARGP_ERR_UNKNOWN;
468
{
469
char *plugin_option;
470
while((plugin_option = strsep(&arg, ",")) != NULL){
471
if(not add_argument(getplugin(NULL), plugin_option)){
472
break;
393
473
}
394
474
}
475
errno = 0;
395
476
}
396
477
break;
397
478
case 'G': /* --global-env */
398
if(arg == NULL){
399
break;
400
}
401
if(not add_environment(getplugin(NULL), arg, true)){
402
perror("add_environment");
479
if(add_environment(getplugin(NULL), arg, true)){
480
errno = 0;
403
481
}
404
482
break;
405
483
case 'o': /* --options-for */
406
if(arg != NULL){
407
char *p_name = strsep(&arg, ":");
408
if(p_name[0] == '\0' or arg == NULL){
409
break;
410
}
411
char *opt = strsep(&arg, ":");
412
if(opt[0] == '\0' or opt == NULL){
413
break;
414
}
415
char *p;
416
while((p = strsep(&opt, ",")) != NULL){
417
if(p[0] == '\0'){
418
continue;
419
}
420
if(not add_argument(getplugin(p_name), p)){
421
perror("add_argument");
422
return ARGP_ERR_UNKNOWN;
423
}
424
}
484
{
485
char *option_list = strchr(arg, ':');
486
if(option_list == NULL){
487
argp_error(state, "No colon in \"%s\"", arg);
488
errno = EINVAL;
489
break;
490
}
491
*option_list = '\0';
492
option_list++;
493
if(arg[0] == '\0'){
494
argp_error(state, "Empty plugin name");
495
errno = EINVAL;
496
break;
497
}
498
char *option;
499
while((option = strsep(&option_list, ",")) != NULL){
500
if(not add_argument(getplugin(arg), option)){
501
break;
502
}
503
}
504
errno = 0;
425
505
}
426
506
break;
427
507
case 'E': /* --env-for */
428
if(arg == NULL){
429
break;
430
}
431
508
{
432
509
char *envdef = strchr(arg, ':');
433
510
if(envdef == NULL){
511
argp_error(state, "No colon in \"%s\"", arg);
512
errno = EINVAL;
434
513
break;
435
514
}
436
515
*envdef = '\0';
437
if(not add_environment(getplugin(arg), envdef+1, true)){
438
perror("add_environment");
516
envdef++;
517
if(arg[0] == '\0'){
518
argp_error(state, "Empty plugin name");
519
errno = EINVAL;
520
break;
521
}
522
if(add_environment(getplugin(arg), envdef, true)){
523
errno = 0;
439
524
}
440
525
}
441
526
break;
442
527
case 'd': /* --disable */
443
if(arg != NULL){
528
{
444
529
plugin *p = getplugin(arg);
445
if(p == NULL){
446
return ARGP_ERR_UNKNOWN;
530
if(p != NULL){
531
p->disabled = true;
532
errno = 0;
447
533
}
448
p->disabled = true;
449
534
}
450
535
break;
451
536
case 'e': /* --enable */
452
if(arg != NULL){
537
{
453
538
plugin *p = getplugin(arg);
454
if(p == NULL){
455
return ARGP_ERR_UNKNOWN;
539
if(p != NULL){
540
p->disabled = false;
541
errno = 0;
456
542
}
457
p->disabled = false;
458
543
}
459
544
break;
460
545
case 128: /* --plugin-dir */
461
546
free(plugindir);
462
547
plugindir = strdup(arg);
463
if(plugindir == NULL){
464
perror("strdup");
465
}
548
if(plugindir != NULL){
549
errno = 0;
550
}
466
551
break;
467
552
case 129: /* --config-file */
468
553
/* This is already done by parse_opt_config_file() */
469
554
break;
470
555
case 130: /* --userid */
471
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
472
if(ret < 1 or tmpmax != (uid_t)tmpmax
473
or arg[numchars] != '\0'){
474
fprintf(stderr, "Bad user ID number: \"%s\", using %"
475
PRIdMAX "\n", arg, (intmax_t)uid);
476
} else {
477
uid = (uid_t)tmpmax;
556
tmp_id = strtoimax(arg, &tmp, 10);
557
if(errno != 0 or tmp == arg or *tmp != '\0'
558
or tmp_id != (uid_t)tmp_id){
559
argp_error(state, "Bad user ID number: \"%s\", using %"
560
PRIdMAX, arg, (intmax_t)uid);
561
break;
478
562
}
563
uid = (uid_t)tmp_id;
564
errno = 0;
479
565
break;
480
566
case 131: /* --groupid */
481
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
482
if(ret < 1 or tmpmax != (gid_t)tmpmax
483
or arg[numchars] != '\0'){
484
fprintf(stderr, "Bad group ID number: \"%s\", using %"
485
PRIdMAX "\n", arg, (intmax_t)gid);
486
} else {
487
gid = (gid_t)tmpmax;
567
tmp_id = strtoimax(arg, &tmp, 10);
568
if(errno != 0 or tmp == arg or *tmp != '\0'
569
or tmp_id != (gid_t)tmp_id){
570
argp_error(state, "Bad group ID number: \"%s\", using %"
571
PRIdMAX, arg, (intmax_t)gid);
572
break;
488
573
}
574
gid = (gid_t)tmp_id;
575
errno = 0;
489
576
break;
490
577
case 132: /* --debug */
491
578
debug = true;
492
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;
587
/*
588
* These reproduce what we would get without ARGP_NO_HELP
589
*/
590
case '?': /* --help */
591
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
592
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
593
__builtin_unreachable();
594
case -3: /* --usage */
595
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
596
argp_state_help(state, state->out_stream,
597
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
598
__builtin_unreachable();
599
case 'V': /* --version */
600
fprintf(state->out_stream, "%s\n", argp_program_version);
601
exit(EXIT_SUCCESS);
602
break;
493
603
/*
494
604
* When adding more options before this line, remember to also add a
495
605
* "case" to the "parse_opt_config_file" function below.
498
608
/* Cryptsetup always passes an argument, which is an empty
499
609
string if "none" was specified in /etc/crypttab. So if
500
610
argument was empty, we ignore it silently. */
501
if(arg[0] != '\0'){
502
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
611
if(arg[0] == '\0'){
612
break;
503
613
}
504
break;
505
case ARGP_KEY_END:
506
break;
614
#if __GNUC__ >= 7
615
__attribute__((fallthrough));
616
#else
617
/* FALLTHROUGH */
618
#endif
507
619
default:
508
620
return ARGP_ERR_UNKNOWN;
509
621
}
510
return 0;
622
return errno; /* Set to 0 at start */
511
623
}
512
624
513
625
/* This option parser is the same as parse_opt() above, except it
515
627
error_t parse_opt_config_file(int key, char *arg,
516
628
__attribute__((unused))
517
629
struct argp_state *state){
630
errno = 0;
518
631
switch(key){
519
632
case 'g': /* --global-options */
520
633
case 'G': /* --global-env */
527
640
case 129: /* --config-file */
528
641
free(argfile);
529
642
argfile = strdup(arg);
530
if(argfile == NULL){
531
perror("strdup");
643
if(argfile != NULL){
644
errno = 0;
532
645
}
533
break;
646
break;
534
647
case 130: /* --userid */
535
648
case 131: /* --groupid */
536
649
case 132: /* --debug */
650
case 133: /* --plugin-helper-dir */
651
case '?': /* --help */
652
case -3: /* --usage */
653
case 'V': /* --version */
537
654
case ARGP_KEY_ARG:
538
case ARGP_KEY_END:
539
655
break;
540
656
default:
541
657
return ARGP_ERR_UNKNOWN;
542
658
}
543
return 0;
659
return errno;
544
660
}
545
661
546
662
struct argp argp = { .options = options,
550
666
551
667
/* Parse using parse_opt_config_file() in order to get the custom
552
668
config file location, if any. */
553
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
554
if(ret == ARGP_ERR_UNKNOWN){
555
fprintf(stderr, "Unknown error while parsing arguments\n");
556
exitstatus = EXIT_FAILURE;
669
ret = argp_parse(&argp, argc, argv,
670
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
671
NULL, NULL);
672
switch(ret){
673
case 0:
674
break;
675
case ENOMEM:
676
default:
677
errno = ret;
678
error(0, errno, "argp_parse");
679
exitstatus = EX_OSERR;
680
goto fallback;
681
case EINVAL:
682
exitstatus = EX_USAGE;
557
683
goto fallback;
558
684
}
559
685
565
691
conffp = fopen(AFILE, "r");
566
692
} else {
567
693
conffp = fopen(argfile, "r");
568
}
694
}
569
695
if(conffp != NULL){
570
696
char *org_line = NULL;
571
697
char *p, *arg, *new_arg, *line;
572
698
size_t size = 0;
573
699
const char whitespace_delims[] = " \r\t\f\v\n";
574
700
const char comment_delim[] = "#";
575
701
576
702
custom_argc = 1;
577
703
custom_argv = malloc(sizeof(char*) * 2);
578
704
if(custom_argv == NULL){
579
perror("malloc");
580
exitstatus = EXIT_FAILURE;
705
error(0, errno, "malloc");
706
exitstatus = EX_OSERR;
581
707
goto fallback;
582
708
}
583
709
custom_argv[0] = argv[0];
584
710
custom_argv[1] = NULL;
585
711
586
712
/* for each line in the config file, strip whitespace and ignore
587
713
commented text */
588
714
while(true){
590
716
if(sret == -1){
591
717
break;
592
718
}
593
719
594
720
line = org_line;
595
721
arg = strsep(&line, comment_delim);
596
722
while((p = strsep(&arg, whitespace_delims)) != NULL){
599
725
}
600
726
new_arg = strdup(p);
601
727
if(new_arg == NULL){
602
perror("strdup");
603
exitstatus = EXIT_FAILURE;
728
error(0, errno, "strdup");
729
exitstatus = EX_OSERR;
604
730
free(org_line);
605
731
goto fallback;
606
732
}
607
733
608
734
custom_argc += 1;
609
custom_argv = realloc(custom_argv, sizeof(char *)
610
* ((unsigned int) custom_argc + 1));
611
if(custom_argv == NULL){
612
perror("realloc");
613
exitstatus = EXIT_FAILURE;
614
free(org_line);
615
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
}
616
758
}
617
759
custom_argv[custom_argc-1] = new_arg;
618
custom_argv[custom_argc] = NULL;
760
custom_argv[custom_argc] = NULL;
619
761
}
620
762
}
763
do {
764
ret = fclose(conffp);
765
} while(ret == EOF and errno == EINTR);
766
if(ret == EOF){
767
error(0, errno, "fclose");
768
exitstatus = EX_IOERR;
769
goto fallback;
770
}
621
771
free(org_line);
622
772
} else {
623
773
/* Check for harmful errors and go to fallback. Other errors might
624
774
not affect opening plugins */
625
775
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
626
perror("fopen");
627
exitstatus = EXIT_FAILURE;
776
error(0, errno, "fopen");
777
exitstatus = EX_OSERR;
628
778
goto fallback;
629
779
}
630
780
}
631
/* If there was any arguments from configuration file,
632
pass them to parser as command arguments */
781
/* If there were any arguments from the configuration file, pass
782
them to parser as command line arguments */
633
783
if(custom_argv != NULL){
634
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
635
0, NULL);
636
if(ret == ARGP_ERR_UNKNOWN){
637
fprintf(stderr, "Unknown error while parsing arguments\n");
638
exitstatus = EXIT_FAILURE;
784
ret = argp_parse(&argp, custom_argc, custom_argv,
785
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
786
NULL, NULL);
787
switch(ret){
788
case 0:
789
break;
790
case ENOMEM:
791
default:
792
errno = ret;
793
error(0, errno, "argp_parse");
794
exitstatus = EX_OSERR;
795
goto fallback;
796
case EINVAL:
797
exitstatus = EX_CONFIG;
639
798
goto fallback;
640
799
}
641
800
}
642
801
643
802
/* Parse actual command line arguments, to let them override the
644
803
config file */
645
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
646
if(ret == ARGP_ERR_UNKNOWN){
647
fprintf(stderr, "Unknown error while parsing arguments\n");
648
exitstatus = EXIT_FAILURE;
649
goto fallback;
804
ret = argp_parse(&argp, argc, argv,
805
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
806
NULL, NULL);
807
switch(ret){
808
case 0:
809
break;
810
case ENOMEM:
811
default:
812
errno = ret;
813
error(0, errno, "argp_parse");
814
exitstatus = EX_OSERR;
815
goto fallback;
816
case EINVAL:
817
exitstatus = EX_USAGE;
818
goto fallback;
819
}
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
}
650
837
}
651
838
652
839
if(debug){
653
for(plugin *p = plugin_list; p != NULL; p=p->next){
840
for(plugin *p = plugin_list; p != NULL; p = p->next){
654
841
fprintf(stderr, "Plugin: %s has %d arguments\n",
655
842
p->name ? p->name : "Global", p->argc - 1);
656
843
for(char **a = p->argv; *a != NULL; a++){
663
850
}
664
851
}
665
852
666
/* Strip permissions down to nobody */
667
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);
668
888
if(ret == -1){
669
perror("setgid");
889
error(0, errno, "setgid");
670
890
}
671
891
ret = setuid(uid);
672
892
if(ret == -1){
673
perror("setuid");
674
}
675
676
if(plugindir == NULL){
677
dir = opendir(PDIR);
678
} else {
679
dir = opendir(plugindir);
680
}
681
682
if(dir == NULL){
683
perror("Could not open plugin dir");
684
exitstatus = EXIT_FAILURE;
685
goto fallback;
686
}
687
688
/* Set the FD_CLOEXEC flag on the directory, if possible */
893
error(0, errno, "setuid");
894
}
895
896
/* Open plugin directory with close_on_exec flag */
689
897
{
690
int dir_fd = dirfd(dir);
691
if(dir_fd >= 0){
692
ret = set_cloexec_flag(dir_fd);
693
if(ret < 0){
694
perror("set_cloexec_flag");
695
exitstatus = EXIT_FAILURE;
696
goto fallback;
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
);
905
if(dir_fd == -1){
906
error(0, errno, "Could not open plugin dir");
907
exitstatus = EX_UNAVAILABLE;
908
goto fallback;
909
}
910
911
#ifndef O_CLOEXEC
912
/* Set the FD_CLOEXEC flag on the directory */
913
ret = set_cloexec_flag(dir_fd);
914
if(ret < 0){
915
error(0, errno, "set_cloexec_flag");
916
exitstatus = EX_OSERR;
917
goto fallback;
918
}
919
#endif /* O_CLOEXEC */
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;
697
942
}
698
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;
699
954
}
700
955
701
956
FD_ZERO(&rfds_all);
702
957
703
958
/* Read and execute any executable in the plugin directory*/
704
while(true){
705
dirst = readdir(dir);
706
707
/* All directory entries have been processed */
708
if(dirst == NULL){
709
if(errno == EBADF){
710
perror("readdir");
711
exitstatus = EXIT_FAILURE;
712
goto fallback;
713
}
714
break;
715
}
716
717
d_name_len = strlen(dirst->d_name);
718
719
/* Ignore dotfiles, backup files and other junk */
720
{
721
bool bad_name = false;
722
723
const char const *bad_prefixes[] = { ".", "#", NULL };
724
725
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
726
".dpkg-old",
727
".dpkg-bak",
728
".dpkg-divert", NULL };
729
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
730
size_t pre_len = strlen(*pre);
731
if((d_name_len >= pre_len)
732
and strncmp((dirst->d_name), *pre, pre_len) == 0){
733
if(debug){
734
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
735
" with bad prefix %s\n", dirst->d_name, *pre);
736
}
737
bad_name = true;
738
break;
739
}
740
}
741
if(bad_name){
742
continue;
743
}
744
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
745
size_t suf_len = strlen(*suf);
746
if((d_name_len >= suf_len)
747
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
748
== 0)){
749
if(debug){
750
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
751
" with bad suffix %s\n", dirst->d_name, *suf);
752
}
753
bad_name = true;
754
break;
755
}
756
}
757
758
if(bad_name){
759
continue;
760
}
761
}
762
763
char *filename;
764
if(plugindir == NULL){
765
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
766
} else {
767
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
768
}
769
if(ret < 0){
770
perror("asprintf");
959
for(int i = 0; i < numplugins; i++){
960
961
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
962
if(plugin_fd == -1){
963
error(0, errno, "Could not open plugin");
964
free(direntries[i]);
771
965
continue;
772
966
}
773
774
ret = stat(filename, &st);
967
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
775
968
if(ret == -1){
776
perror("stat");
777
free(filename);
969
error(0, errno, "stat");
970
close(plugin_fd);
971
free(direntries[i]);
778
972
continue;
779
973
}
780
974
781
975
/* Ignore non-executable files */
782
if(not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
976
if(not S_ISREG(st.st_mode)
977
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
978
X_OK, 0)) != 0)){
783
979
if(debug){
784
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
785
" 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);
786
984
}
787
free(filename);
985
close(plugin_fd);
986
free(direntries[i]);
788
987
continue;
789
988
}
790
989
791
plugin *p = getplugin(dirst->d_name);
990
plugin *p = getplugin(direntries[i]->d_name);
792
991
if(p == NULL){
793
perror("getplugin");
794
free(filename);
992
error(0, errno, "getplugin");
993
close(plugin_fd);
994
free(direntries[i]);
795
995
continue;
796
996
}
797
997
if(p->disabled){
798
998
if(debug){
799
999
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
800
dirst->d_name);
1000
direntries[i]->d_name);
801
1001
}
802
free(filename);
1002
close(plugin_fd);
1003
free(direntries[i]);
803
1004
continue;
804
1005
}
805
1006
{
808
1009
if(g != NULL){
809
1010
for(char **a = g->argv + 1; *a != NULL; a++){
810
1011
if(not add_argument(p, *a)){
811
perror("add_argument");
1012
error(0, errno, "add_argument");
812
1013
}
813
1014
}
814
1015
/* Add global environment variables */
815
1016
for(char **e = g->environ; *e != NULL; e++){
816
1017
if(not add_environment(p, *e, false)){
817
perror("add_environment");
1018
error(0, errno, "add_environment");
818
1019
}
819
1020
}
820
1021
}
821
1022
}
822
/* If this plugin has any environment variables, we will call
823
using execve and need to duplicate the environment from this
824
process, too. */
1023
/* If this plugin has any environment variables, we need to
1024
duplicate the environment from this process, too. */
825
1025
if(p->environ[0] != NULL){
826
1026
for(char **e = environ; *e != NULL; e++){
827
1027
if(not add_environment(p, *e, false)){
828
perror("add_environment");
1028
error(0, errno, "add_environment");
829
1029
}
830
1030
}
831
1031
}
832
1032
833
1033
int pipefd[2];
834
ret = pipe(pipefd);
1034
#ifndef O_CLOEXEC
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 */
835
1039
if(ret == -1){
836
perror("pipe");
837
exitstatus = EXIT_FAILURE;
838
goto fallback;
839
}
1040
error(0, errno, "pipe");
1041
exitstatus = EX_OSERR;
1042
free(direntries[i]);
1043
goto fallback;
1044
}
1045
if(pipefd[0] >= FD_SETSIZE){
1046
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1047
FD_SETSIZE);
1048
close(pipefd[0]);
1049
close(pipefd[1]);
1050
exitstatus = EX_OSERR;
1051
free(direntries[i]);
1052
goto fallback;
1053
}
1054
#ifndef O_CLOEXEC
840
1055
/* Ask OS to automatic close the pipe on exec */
841
1056
ret = set_cloexec_flag(pipefd[0]);
842
1057
if(ret < 0){
843
perror("set_cloexec_flag");
844
exitstatus = EXIT_FAILURE;
1058
error(0, errno, "set_cloexec_flag");
1059
close(pipefd[0]);
1060
close(pipefd[1]);
1061
exitstatus = EX_OSERR;
1062
free(direntries[i]);
845
1063
goto fallback;
846
1064
}
847
1065
ret = set_cloexec_flag(pipefd[1]);
848
1066
if(ret < 0){
849
perror("set_cloexec_flag");
850
exitstatus = EXIT_FAILURE;
1067
error(0, errno, "set_cloexec_flag");
1068
close(pipefd[0]);
1069
close(pipefd[1]);
1070
exitstatus = EX_OSERR;
1071
free(direntries[i]);
851
1072
goto fallback;
852
1073
}
1074
#endif /* not O_CLOEXEC */
853
1075
/* Block SIGCHLD until process is safely in process list */
854
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1076
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1077
&sigchld_action.sa_mask,
1078
NULL));
855
1079
if(ret < 0){
856
perror("sigprocmask");
857
exitstatus = EXIT_FAILURE;
1080
error(0, errno, "sigprocmask");
1081
exitstatus = EX_OSERR;
1082
free(direntries[i]);
858
1083
goto fallback;
859
1084
}
860
1085
/* Starting a new process to be watched */
861
pid_t pid = fork();
1086
pid_t pid;
1087
do {
1088
pid = fork();
1089
} while(pid == -1 and errno == EINTR);
862
1090
if(pid == -1){
863
perror("fork");
864
exitstatus = EXIT_FAILURE;
1091
error(0, errno, "fork");
1092
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1093
&sigchld_action.sa_mask, NULL));
1094
close(pipefd[0]);
1095
close(pipefd[1]);
1096
exitstatus = EX_OSERR;
1097
free(direntries[i]);
865
1098
goto fallback;
866
1099
}
867
1100
if(pid == 0){
868
1101
/* this is the child process */
869
1102
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
870
1103
if(ret < 0){
871
perror("sigaction");
872
_exit(EXIT_FAILURE);
1104
error(0, errno, "sigaction");
1105
_exit(EX_OSERR);
873
1106
}
874
1107
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
875
1108
if(ret < 0){
876
perror("sigprocmask");
877
_exit(EXIT_FAILURE);
1109
error(0, errno, "sigprocmask");
1110
_exit(EX_OSERR);
878
1111
}
879
1112
880
1113
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
881
1114
if(ret == -1){
882
perror("dup2");
883
_exit(EXIT_FAILURE);
1115
error(0, errno, "dup2");
1116
_exit(EX_OSERR);
884
1117
}
885
1118
886
if(dirfd(dir) < 0){
887
/* If dir has no file descriptor, we could not set FD_CLOEXEC
888
above and must now close it manually here. */
889
closedir(dir);
890
}
891
if(p->environ[0] == NULL){
892
if(execv(filename, p->argv) < 0){
893
perror("execv");
894
_exit(EXIT_FAILURE);
895
}
896
} else {
897
if(execve(filename, p->argv, p->environ) < 0){
898
perror("execve");
899
_exit(EXIT_FAILURE);
900
}
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);
901
1125
}
902
1126
/* no return */
903
1127
}
904
1128
/* Parent process */
905
1129
close(pipefd[1]); /* Close unused write end of pipe */
906
free(filename);
907
plugin *new_plugin = getplugin(dirst->d_name);
1130
close(plugin_fd);
1131
plugin *new_plugin = getplugin(direntries[i]->d_name);
908
1132
if(new_plugin == NULL){
909
perror("getplugin");
910
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1133
error(0, errno, "getplugin");
1134
ret = (int)(TEMP_FAILURE_RETRY
1135
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1136
NULL)));
911
1137
if(ret < 0){
912
perror("sigprocmask");
1138
error(0, errno, "sigprocmask");
913
1139
}
914
exitstatus = EXIT_FAILURE;
1140
exitstatus = EX_OSERR;
1141
free(direntries[i]);
915
1142
goto fallback;
916
1143
}
1144
free(direntries[i]);
917
1145
918
1146
new_plugin->pid = pid;
919
1147
new_plugin->fd = pipefd[0];
920
1148
1149
if(debug){
1150
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1151
new_plugin->name, (intmax_t) (new_plugin->pid));
1152
}
1153
921
1154
/* Unblock SIGCHLD so signal handler can be run if this process
922
1155
has already completed */
923
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1156
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1157
&sigchld_action.sa_mask,
1158
NULL));
924
1159
if(ret < 0){
925
perror("sigprocmask");
926
exitstatus = EXIT_FAILURE;
1160
error(0, errno, "sigprocmask");
1161
exitstatus = EX_OSERR;
927
1162
goto fallback;
928
1163
}
929
1164
934
1169
}
935
1170
}
936
1171
937
closedir(dir);
938
dir = NULL;
1172
free(direntries);
1173
direntries = NULL;
1174
close(dir_fd);
1175
dir_fd = -1;
1176
free_plugin(getplugin(NULL));
939
1177
940
1178
for(plugin *p = plugin_list; p != NULL; p = p->next){
941
1179
if(p->pid != 0){
952
1190
while(plugin_list){
953
1191
fd_set rfds = rfds_all;
954
1192
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
955
if(select_ret == -1){
956
perror("select");
957
exitstatus = EXIT_FAILURE;
1193
if(select_ret == -1 and errno != EINTR){
1194
error(0, errno, "select");
1195
exitstatus = EX_OSERR;
958
1196
goto fallback;
959
1197
}
960
1198
/* OK, now either a process completed, or something can be read
966
1204
if(not WIFEXITED(proc->status)
967
1205
or WEXITSTATUS(proc->status) != 0){
968
1206
/* Bad exit by plugin */
969
1207
970
1208
if(debug){
971
1209
if(WIFEXITED(proc->status)){
972
1210
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
975
1213
WEXITSTATUS(proc->status));
976
1214
} else if(WIFSIGNALED(proc->status)){
977
1215
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
978
" signal %d\n", proc->name,
1216
" signal %d: %s\n", proc->name,
979
1217
(intmax_t) (proc->pid),
980
WTERMSIG(proc->status));
981
} else if(WCOREDUMP(proc->status)){
982
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
983
" core\n", proc->name, (intmax_t) (proc->pid));
1218
WTERMSIG(proc->status),
1219
strsignal(WTERMSIG(proc->status)));
984
1220
}
985
1221
}
986
1222
987
1223
/* Remove the plugin */
988
1224
FD_CLR(proc->fd, &rfds_all);
989
1225
990
1226
/* Block signal while modifying process_list */
991
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1227
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1228
(SIG_BLOCK,
1229
&sigchld_action.sa_mask,
1230
NULL));
992
1231
if(ret < 0){
993
perror("sigprocmask");
994
exitstatus = EXIT_FAILURE;
1232
error(0, errno, "sigprocmask");
1233
exitstatus = EX_OSERR;
995
1234
goto fallback;
996
1235
}
997
1236
1000
1239
proc = next_plugin;
1001
1240
1002
1241
/* We are done modifying process list, so unblock signal */
1003
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1004
NULL);
1242
ret = (int)(TEMP_FAILURE_RETRY
1243
(sigprocmask(SIG_UNBLOCK,
1244
&sigchld_action.sa_mask, NULL)));
1005
1245
if(ret < 0){
1006
perror("sigprocmask");
1007
exitstatus = EXIT_FAILURE;
1246
error(0, errno, "sigprocmask");
1247
exitstatus = EX_OSERR;
1008
1248
goto fallback;
1009
1249
}
1010
1250
1020
1260
bool bret = print_out_password(proc->buffer,
1021
1261
proc->buffer_length);
1022
1262
if(not bret){
1023
perror("print_out_password");
1024
exitstatus = EXIT_FAILURE;
1263
error(0, errno, "print_out_password");
1264
exitstatus = EX_IOERR;
1025
1265
}
1026
1266
goto fallback;
1027
1267
}
1034
1274
}
1035
1275
/* Before reading, make the process' data buffer large enough */
1036
1276
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1037
proc->buffer = realloc(proc->buffer, proc->buffer_size
1038
+ (size_t) BUFFER_SIZE);
1039
if(proc->buffer == NULL){
1040
perror("malloc");
1041
exitstatus = EXIT_FAILURE;
1277
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1278
+ (size_t) BUFFER_SIZE);
1279
if(new_buffer == NULL){
1280
error(0, errno, "malloc");
1281
exitstatus = EX_OSERR;
1042
1282
goto fallback;
1043
1283
}
1284
proc->buffer = new_buffer;
1044
1285
proc->buffer_size += BUFFER_SIZE;
1045
1286
}
1046
1287
/* Read from the process */
1047
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1048
BUFFER_SIZE);
1288
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1289
proc->buffer
1290
+ proc->buffer_length,
1291
BUFFER_SIZE));
1049
1292
if(sret < 0){
1050
1293
/* Read error from this process; ignore the error */
1051
1294
proc = proc->next;
1059
1302
}
1060
1303
}
1061
1304
}
1062
1063
1305
1306
1064
1307
fallback:
1065
1308
1066
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1309
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1310
and exitstatus != EX_OK)){
1067
1311
/* Fallback if all plugins failed, none are found or an error
1068
1312
occured */
1069
1313
bool bret;
1077
1321
}
1078
1322
bret = print_out_password(passwordbuffer, len);
1079
1323
if(not bret){
1080
perror("print_out_password");
1081
exitstatus = EXIT_FAILURE;
1324
error(0, errno, "print_out_password");
1325
exitstatus = EX_IOERR;
1082
1326
}
1083
1327
}
1084
1328
1085
1329
/* Restore old signal handler */
1086
1330
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1087
1331
if(ret == -1){
1088
perror("sigaction");
1089
exitstatus = EXIT_FAILURE;
1332
error(0, errno, "sigaction");
1333
exitstatus = EX_OSERR;
1090
1334
}
1091
1335
1092
1336
if(custom_argv != NULL){
1096
1340
free(custom_argv);
1097
1341
}
1098
1342
1099
if(dir != NULL){
1100
closedir(dir);
1343
free(direntries);
1344
1345
if(dir_fd != -1){
1346
close(dir_fd);
1101
1347
}
1102
1348
1103
1349
/* Kill the processes */
1107
1353
ret = kill(p->pid, SIGTERM);
1108
1354
if(ret == -1 and errno != ESRCH){
1109
1355
/* Set-uid proccesses might not get closed */
1110
perror("kill");
1356
error(0, errno, "kill");
1111
1357
}
1112
1358
}
1113
1359
}
1114
1360
1115
1361
/* Wait for any remaining child processes to terminate */
1116
do{
1362
do {
1117
1363
ret = wait(NULL);
1118
1364
} while(ret >= 0);
1119
1365
if(errno != ECHILD){
1120
perror("wait");
1366
error(0, errno, "wait");
1121
1367
}
1122
1368
1123
1369
free_plugin_list();
1124
1370
1125
1371
free(plugindir);
1372
free(pluginhelperdir);
1126
1373
free(argfile);
1127
1374
1128
1375
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0