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