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