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