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