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