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