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