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