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 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,
66
68
*/
67
69
#include <errno.h> /* errno, EBADF */
68
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() */
69
75
70
76
#define BUFFER_SIZE 256
71
77
73
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
74
80
75
81
const char *argp_program_version = "plugin-runner " VERSION;
76
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
82
const char *argp_program_bug_address = "<mandos@recompile.se>";
77
83
78
84
typedef struct plugin{
79
85
char *name; /* can be NULL or any plugin name */
100
106
/* Gets an existing plugin based on name,
101
107
or if none is found, creates a new one */
102
108
static plugin *getplugin(char *name){
103
/* Check for exiting plugin with that name */
109
/* Check for existing plugin with that name */
104
110
for(plugin *p = plugin_list; p != NULL; p = p->next){
105
111
if((p->name == name)
106
112
or (p->name and name and (strcmp(p->name, name) == 0))){
108
114
}
109
115
}
110
116
/* Create a new plugin */
111
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);
112
121
if(new_plugin == NULL){
113
122
return NULL;
114
123
}
115
124
char *copy_name = NULL;
116
125
if(name != NULL){
117
copy_name = strdup(name);
126
do {
127
copy_name = strdup(name);
128
} while(copy_name == NULL and errno == EINTR);
118
129
if(copy_name == NULL){
130
int e = errno;
119
131
free(new_plugin);
132
errno = e;
120
133
return NULL;
121
134
}
122
135
}
126
139
.disabled = false,
127
140
.next = plugin_list };
128
141
129
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);
130
145
if(new_plugin->argv == NULL){
146
int e = errno;
131
147
free(copy_name);
132
148
free(new_plugin);
149
errno = e;
133
150
return NULL;
134
151
}
135
152
new_plugin->argv[0] = copy_name;
136
153
new_plugin->argv[1] = NULL;
137
154
138
new_plugin->environ = malloc(sizeof(char *));
155
do {
156
new_plugin->environ = malloc(sizeof(char *));
157
} while(new_plugin->environ == NULL and errno == EINTR);
139
158
if(new_plugin->environ == NULL){
159
int e = errno;
140
160
free(copy_name);
141
161
free(new_plugin->argv);
142
162
free(new_plugin);
163
errno = e;
143
164
return NULL;
144
165
}
145
166
new_plugin->environ[0] = NULL;
150
171
}
151
172
152
173
/* Helper function for add_argument and add_environment */
174
__attribute__((nonnull))
153
175
static bool add_to_char_array(const char *new, char ***array,
154
176
int *len){
155
177
/* Resize the pointed-to array to hold one more pointer */
156
*array = realloc(*array, sizeof(char *)
157
* (size_t) ((*len) + 2));
178
do {
179
*array = realloc(*array, sizeof(char *)
180
* (size_t) ((*len) + 2));
181
} while(*array == NULL and errno == EINTR);
158
182
/* Malloc check */
159
183
if(*array == NULL){
160
184
return false;
161
185
}
162
186
/* Make a copy of the new string */
163
char *copy = strdup(new);
187
char *copy;
188
do {
189
copy = strdup(new);
190
} while(copy == NULL and errno == EINTR);
164
191
if(copy == NULL){
165
192
return false;
166
193
}
173
200
}
174
201
175
202
/* Add to a plugin's argument vector */
203
__attribute__((nonnull(2)))
176
204
static bool add_argument(plugin *p, const char *arg){
177
205
if(p == NULL){
178
206
return false;
181
209
}
182
210
183
211
/* Add to a plugin's environment */
212
__attribute__((nonnull(2)))
184
213
static bool add_environment(plugin *p, const char *def, bool replace){
185
214
if(p == NULL){
186
215
return false;
192
221
if(strncmp(*e, def, namelen + 1) == 0){
193
222
/* It already exists */
194
223
if(replace){
195
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);
196
228
if(new == NULL){
197
229
return false;
198
230
}
208
240
/*
209
241
* Based on the example in the GNU LibC manual chapter 13.13 "File
210
242
* Descriptor Flags".
211
* *Note File Descriptor Flags:(libc)Descriptor Flags.
243
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
212
244
*/
213
245
static int set_cloexec_flag(int fd){
214
int ret = fcntl(fd, F_GETFD, 0);
246
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
215
247
/* If reading the flags failed, return error indication now. */
216
248
if(ret < 0){
217
249
return ret;
218
250
}
219
251
/* Store modified flag word in the descriptor. */
220
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
252
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
ret | FD_CLOEXEC));
221
254
}
222
255
223
256
238
271
/* No child processes */
239
272
break;
240
273
}
241
perror("waitpid");
274
error(0, errno, "waitpid");
242
275
}
243
276
244
277
/* A child exited, find it in process_list */
256
289
}
257
290
258
291
/* Prints out a password to stdout */
292
__attribute__((nonnull))
259
293
static bool print_out_password(const char *buffer, size_t length){
260
294
ssize_t ret;
261
295
for(size_t written = 0; written < length; written += (size_t)ret){
269
303
}
270
304
271
305
/* Removes and free a plugin from the plugin list */
306
__attribute__((nonnull))
272
307
static void free_plugin(plugin *plugin_node){
273
308
274
309
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
315
350
fd_set rfds_all;
316
351
int ret, maxfd = 0;
317
352
ssize_t sret;
318
intmax_t tmpmax;
319
353
uid_t uid = 65534;
320
354
gid_t gid = 65534;
321
355
bool debug = false;
330
364
sigemptyset(&sigchld_action.sa_mask);
331
365
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
332
366
if(ret == -1){
333
perror("sigaddset");
334
exitstatus = EXIT_FAILURE;
367
error(0, errno, "sigaddset");
368
exitstatus = EX_OSERR;
335
369
goto fallback;
336
370
}
337
371
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
338
372
if(ret == -1){
339
perror("sigaction");
340
exitstatus = EXIT_FAILURE;
373
error(0, errno, "sigaction");
374
exitstatus = EX_OSERR;
341
375
goto fallback;
342
376
}
343
377
375
409
.doc = "Group ID the plugins will run as", .group = 3 },
376
410
{ .name = "debug", .key = 132,
377
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 },
378
421
{ .name = NULL }
379
422
};
380
423
381
error_t parse_opt(int key, char *arg, __attribute__((unused))
382
struct argp_state *state){
383
char *tmp;
424
__attribute__((nonnull(3)))
425
error_t parse_opt(int key, char *arg, struct argp_state *state){
426
errno = 0;
384
427
switch(key){
428
char *tmp;
429
intmax_t tmp_id;
385
430
case 'g': /* --global-options */
386
if(arg != NULL){
431
{
387
432
char *plugin_option;
388
433
while((plugin_option = strsep(&arg, ",")) != NULL){
389
if(plugin_option[0] == '\0'){
390
continue;
391
}
392
434
if(not add_argument(getplugin(NULL), plugin_option)){
393
perror("add_argument");
394
return ARGP_ERR_UNKNOWN;
435
break;
395
436
}
396
437
}
397
438
}
398
439
break;
399
440
case 'G': /* --global-env */
400
if(arg == NULL){
401
break;
402
}
403
if(not add_environment(getplugin(NULL), arg, true)){
404
perror("add_environment");
405
}
441
add_environment(getplugin(NULL), arg, true);
406
442
break;
407
443
case 'o': /* --options-for */
408
if(arg != NULL){
409
char *plugin_name = strsep(&arg, ":");
410
if(plugin_name[0] == '\0'){
411
break;
412
}
413
char *plugin_option;
414
while((plugin_option = strsep(&arg, ",")) != NULL){
415
if(not add_argument(getplugin(plugin_name), plugin_option)){
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
errno = 0;
467
tmpmax = strtoimax(arg, &tmp, 10);
508
tmp_id = strtoimax(arg, &tmp, 10);
468
509
if(errno != 0 or tmp == arg or *tmp != '\0'
469
or tmpmax != (uid_t)tmpmax){
470
fprintf(stderr, "Bad user ID number: \"%s\", using %"
471
PRIdMAX "\n", arg, (intmax_t)uid);
472
} else {
473
uid = (uid_t)tmpmax;
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;
474
514
}
515
uid = (uid_t)tmp_id;
475
516
break;
476
517
case 131: /* --groupid */
477
errno = 0;
478
tmpmax = strtoimax(arg, &tmp, 10);
518
tmp_id = strtoimax(arg, &tmp, 10);
479
519
if(errno != 0 or tmp == arg or *tmp != '\0'
480
or tmpmax != (gid_t)tmpmax){
481
fprintf(stderr, "Bad group ID number: \"%s\", using %"
482
PRIdMAX "\n", arg, (intmax_t)gid);
483
} else {
484
gid = (gid_t)tmpmax;
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;
485
524
}
525
gid = (gid_t)tmp_id;
486
526
break;
487
527
case 132: /* --debug */
488
528
debug = true;
489
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;
490
544
/*
491
545
* When adding more options before this line, remember to also add a
492
546
* "case" to the "parse_opt_config_file" function below.
495
549
/* Cryptsetup always passes an argument, which is an empty
496
550
string if "none" was specified in /etc/crypttab. So if
497
551
argument was empty, we ignore it silently. */
498
if(arg[0] != '\0'){
499
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
552
if(arg[0] == '\0'){
553
break;
500
554
}
501
break;
502
case ARGP_KEY_END:
503
break;
504
555
default:
505
556
return ARGP_ERR_UNKNOWN;
506
557
}
507
return 0;
558
return errno; /* Set to 0 at start */
508
559
}
509
560
510
561
/* This option parser is the same as parse_opt() above, except it
512
563
error_t parse_opt_config_file(int key, char *arg,
513
564
__attribute__((unused))
514
565
struct argp_state *state){
566
errno = 0;
515
567
switch(key){
516
568
case 'g': /* --global-options */
517
569
case 'G': /* --global-env */
524
576
case 129: /* --config-file */
525
577
free(argfile);
526
578
argfile = strdup(arg);
527
if(argfile == NULL){
528
perror("strdup");
529
}
530
break;
579
break;
531
580
case 130: /* --userid */
532
581
case 131: /* --groupid */
533
582
case 132: /* --debug */
583
case '?': /* --help */
584
case -3: /* --usage */
585
case 'V': /* --version */
534
586
case ARGP_KEY_ARG:
535
case ARGP_KEY_END:
536
587
break;
537
588
default:
538
589
return ARGP_ERR_UNKNOWN;
539
590
}
540
return 0;
591
return errno;
541
592
}
542
593
543
594
struct argp argp = { .options = options,
547
598
548
599
/* Parse using parse_opt_config_file() in order to get the custom
549
600
config file location, if any. */
550
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
551
if(ret == ARGP_ERR_UNKNOWN){
552
fprintf(stderr, "Unknown error while parsing arguments\n");
553
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;
554
615
goto fallback;
555
616
}
556
617
562
623
conffp = fopen(AFILE, "r");
563
624
} else {
564
625
conffp = fopen(argfile, "r");
565
}
626
}
566
627
if(conffp != NULL){
567
628
char *org_line = NULL;
568
629
char *p, *arg, *new_arg, *line;
573
634
custom_argc = 1;
574
635
custom_argv = malloc(sizeof(char*) * 2);
575
636
if(custom_argv == NULL){
576
perror("malloc");
577
exitstatus = EXIT_FAILURE;
637
error(0, errno, "malloc");
638
exitstatus = EX_OSERR;
578
639
goto fallback;
579
640
}
580
641
custom_argv[0] = argv[0];
596
657
}
597
658
new_arg = strdup(p);
598
659
if(new_arg == NULL){
599
perror("strdup");
600
exitstatus = EXIT_FAILURE;
660
error(0, errno, "strdup");
661
exitstatus = EX_OSERR;
601
662
free(org_line);
602
663
goto fallback;
603
664
}
606
667
custom_argv = realloc(custom_argv, sizeof(char *)
607
668
* ((unsigned int) custom_argc + 1));
608
669
if(custom_argv == NULL){
609
perror("realloc");
610
exitstatus = EXIT_FAILURE;
670
error(0, errno, "realloc");
671
exitstatus = EX_OSERR;
611
672
free(org_line);
612
673
goto fallback;
613
674
}
614
675
custom_argv[custom_argc-1] = new_arg;
615
custom_argv[custom_argc] = NULL;
676
custom_argv[custom_argc] = NULL;
616
677
}
617
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
}
618
687
free(org_line);
619
688
} else {
620
689
/* Check for harmful errors and go to fallback. Other errors might
621
690
not affect opening plugins */
622
691
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
623
perror("fopen");
624
exitstatus = EXIT_FAILURE;
692
error(0, errno, "fopen");
693
exitstatus = EX_OSERR;
625
694
goto fallback;
626
695
}
627
696
}
628
/* If there was any arguments from configuration file,
629
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 */
630
699
if(custom_argv != NULL){
631
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
632
0, NULL);
633
if(ret == ARGP_ERR_UNKNOWN){
634
fprintf(stderr, "Unknown error while parsing arguments\n");
635
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;
636
714
goto fallback;
637
715
}
638
716
}
639
717
640
718
/* Parse actual command line arguments, to let them override the
641
719
config file */
642
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
643
if(ret == ARGP_ERR_UNKNOWN){
644
fprintf(stderr, "Unknown error while parsing arguments\n");
645
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;
646
734
goto fallback;
647
735
}
648
736
660
748
}
661
749
}
662
750
663
/* 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 */
664
774
setgid(gid);
665
775
if(ret == -1){
666
perror("setgid");
776
error(0, errno, "setgid");
667
777
}
668
778
ret = setuid(uid);
669
779
if(ret == -1){
670
perror("setuid");
671
}
672
673
if(plugindir == NULL){
674
dir = opendir(PDIR);
675
} else {
676
dir = opendir(plugindir);
677
}
678
679
if(dir == NULL){
680
perror("Could not open plugin dir");
681
exitstatus = EXIT_FAILURE;
682
goto fallback;
683
}
684
685
/* 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 */
686
784
{
687
int dir_fd = dirfd(dir);
688
if(dir_fd >= 0){
689
ret = set_cloexec_flag(dir_fd);
690
if(ret < 0){
691
perror("set_cloexec_flag");
692
exitstatus = EXIT_FAILURE;
693
goto fallback;
694
}
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;
695
826
}
696
827
}
697
828
699
830
700
831
/* Read and execute any executable in the plugin directory*/
701
832
while(true){
702
dirst = readdir(dir);
833
do {
834
dirst = readdir(dir);
835
} while(dirst == NULL and errno == EINTR);
703
836
704
837
/* All directory entries have been processed */
705
838
if(dirst == NULL){
706
839
if(errno == EBADF){
707
perror("readdir");
708
exitstatus = EXIT_FAILURE;
840
error(0, errno, "readdir");
841
exitstatus = EX_IOERR;
709
842
goto fallback;
710
843
}
711
844
break;
741
874
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
742
875
size_t suf_len = strlen(*suf);
743
876
if((d_name_len >= suf_len)
744
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
877
and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
745
878
== 0)){
746
879
if(debug){
747
880
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
759
892
760
893
char *filename;
761
894
if(plugindir == NULL){
762
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
895
ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
dirst->d_name));
763
897
} else {
764
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));
765
901
}
766
902
if(ret < 0){
767
perror("asprintf");
903
error(0, errno, "asprintf");
768
904
continue;
769
905
}
770
906
771
ret = stat(filename, &st);
907
ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
772
908
if(ret == -1){
773
perror("stat");
909
error(0, errno, "stat");
774
910
free(filename);
775
911
continue;
776
912
}
777
913
778
914
/* Ignore non-executable files */
779
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)){
780
917
if(debug){
781
918
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
782
919
" with bad type or mode\n", filename);
787
924
788
925
plugin *p = getplugin(dirst->d_name);
789
926
if(p == NULL){
790
perror("getplugin");
927
error(0, errno, "getplugin");
791
928
free(filename);
792
929
continue;
793
930
}
805
942
if(g != NULL){
806
943
for(char **a = g->argv + 1; *a != NULL; a++){
807
944
if(not add_argument(p, *a)){
808
perror("add_argument");
945
error(0, errno, "add_argument");
809
946
}
810
947
}
811
948
/* Add global environment variables */
812
949
for(char **e = g->environ; *e != NULL; e++){
813
950
if(not add_environment(p, *e, false)){
814
perror("add_environment");
951
error(0, errno, "add_environment");
815
952
}
816
953
}
817
954
}
822
959
if(p->environ[0] != NULL){
823
960
for(char **e = environ; *e != NULL; e++){
824
961
if(not add_environment(p, *e, false)){
825
perror("add_environment");
962
error(0, errno, "add_environment");
826
963
}
827
964
}
828
965
}
829
966
830
967
int pipefd[2];
831
ret = pipe(pipefd);
968
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
832
969
if(ret == -1){
833
perror("pipe");
834
exitstatus = EXIT_FAILURE;
970
error(0, errno, "pipe");
971
exitstatus = EX_OSERR;
835
972
goto fallback;
836
973
}
837
974
/* Ask OS to automatic close the pipe on exec */
838
975
ret = set_cloexec_flag(pipefd[0]);
839
976
if(ret < 0){
840
perror("set_cloexec_flag");
841
exitstatus = EXIT_FAILURE;
977
error(0, errno, "set_cloexec_flag");
978
exitstatus = EX_OSERR;
842
979
goto fallback;
843
980
}
844
981
ret = set_cloexec_flag(pipefd[1]);
845
982
if(ret < 0){
846
perror("set_cloexec_flag");
847
exitstatus = EXIT_FAILURE;
983
error(0, errno, "set_cloexec_flag");
984
exitstatus = EX_OSERR;
848
985
goto fallback;
849
986
}
850
987
/* Block SIGCHLD until process is safely in process list */
851
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));
852
991
if(ret < 0){
853
perror("sigprocmask");
854
exitstatus = EXIT_FAILURE;
992
error(0, errno, "sigprocmask");
993
exitstatus = EX_OSERR;
855
994
goto fallback;
856
995
}
857
996
/* Starting a new process to be watched */
858
pid_t pid = fork();
997
pid_t pid;
998
do {
999
pid = fork();
1000
} while(pid == -1 and errno == EINTR);
859
1001
if(pid == -1){
860
perror("fork");
861
exitstatus = EXIT_FAILURE;
1002
error(0, errno, "fork");
1003
exitstatus = EX_OSERR;
862
1004
goto fallback;
863
1005
}
864
1006
if(pid == 0){
865
1007
/* this is the child process */
866
1008
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
867
1009
if(ret < 0){
868
perror("sigaction");
869
_exit(EXIT_FAILURE);
1010
error(0, errno, "sigaction");
1011
_exit(EX_OSERR);
870
1012
}
871
1013
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
872
1014
if(ret < 0){
873
perror("sigprocmask");
874
_exit(EXIT_FAILURE);
1015
error(0, errno, "sigprocmask");
1016
_exit(EX_OSERR);
875
1017
}
876
1018
877
1019
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
878
1020
if(ret == -1){
879
perror("dup2");
880
_exit(EXIT_FAILURE);
1021
error(0, errno, "dup2");
1022
_exit(EX_OSERR);
881
1023
}
882
1024
883
1025
if(dirfd(dir) < 0){
887
1029
}
888
1030
if(p->environ[0] == NULL){
889
1031
if(execv(filename, p->argv) < 0){
890
perror("execv");
891
_exit(EXIT_FAILURE);
1032
error(0, errno, "execv for %s", filename);
1033
_exit(EX_OSERR);
892
1034
}
893
1035
} else {
894
1036
if(execve(filename, p->argv, p->environ) < 0){
895
perror("execve");
896
_exit(EXIT_FAILURE);
1037
error(0, errno, "execve for %s", filename);
1038
_exit(EX_OSERR);
897
1039
}
898
1040
}
899
1041
/* no return */
900
1042
}
901
1043
/* Parent process */
902
close(pipefd[1]); /* Close unused write end of pipe */
1044
TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
pipe */
903
1046
free(filename);
904
1047
plugin *new_plugin = getplugin(dirst->d_name);
905
1048
if(new_plugin == NULL){
906
perror("getplugin");
907
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)));
908
1053
if(ret < 0){
909
perror("sigprocmask");
1054
error(0, errno, "sigprocmask");
910
1055
}
911
exitstatus = EXIT_FAILURE;
1056
exitstatus = EX_OSERR;
912
1057
goto fallback;
913
1058
}
914
1059
917
1062
918
1063
/* Unblock SIGCHLD so signal handler can be run if this process
919
1064
has already completed */
920
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));
921
1068
if(ret < 0){
922
perror("sigprocmask");
923
exitstatus = EXIT_FAILURE;
1069
error(0, errno, "sigprocmask");
1070
exitstatus = EX_OSERR;
924
1071
goto fallback;
925
1072
}
926
1073
927
FD_SET(new_plugin->fd, &rfds_all);
1074
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1075
-Wconversion */
928
1076
929
1077
if(maxfd < new_plugin->fd){
930
1078
maxfd = new_plugin->fd;
931
1079
}
932
1080
}
933
1081
934
closedir(dir);
1082
TEMP_FAILURE_RETRY(closedir(dir));
935
1083
dir = NULL;
936
1084
free_plugin(getplugin(NULL));
937
1085
950
1098
while(plugin_list){
951
1099
fd_set rfds = rfds_all;
952
1100
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
953
if(select_ret == -1){
954
perror("select");
955
exitstatus = EXIT_FAILURE;
1101
if(select_ret == -1 and errno != EINTR){
1102
error(0, errno, "select");
1103
exitstatus = EX_OSERR;
956
1104
goto fallback;
957
1105
}
958
1106
/* OK, now either a process completed, or something can be read
973
1121
WEXITSTATUS(proc->status));
974
1122
} else if(WIFSIGNALED(proc->status)){
975
1123
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
976
" signal %d\n", proc->name,
1124
" signal %d: %s\n", proc->name,
977
1125
(intmax_t) (proc->pid),
978
WTERMSIG(proc->status));
1126
WTERMSIG(proc->status),
1127
strsignal(WTERMSIG(proc->status)));
979
1128
} else if(WCOREDUMP(proc->status)){
980
1129
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
981
1130
" core\n", proc->name, (intmax_t) (proc->pid));
983
1132
}
984
1133
985
1134
/* Remove the plugin */
986
FD_CLR(proc->fd, &rfds_all);
1135
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1136
-Wconversion */
987
1137
988
1138
/* Block signal while modifying process_list */
989
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));
990
1143
if(ret < 0){
991
perror("sigprocmask");
992
exitstatus = EXIT_FAILURE;
1144
error(0, errno, "sigprocmask");
1145
exitstatus = EX_OSERR;
993
1146
goto fallback;
994
1147
}
995
1148
998
1151
proc = next_plugin;
999
1152
1000
1153
/* We are done modifying process list, so unblock signal */
1001
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1002
NULL);
1154
ret = (int)(TEMP_FAILURE_RETRY
1155
(sigprocmask(SIG_UNBLOCK,
1156
&sigchld_action.sa_mask, NULL)));
1003
1157
if(ret < 0){
1004
perror("sigprocmask");
1005
exitstatus = EXIT_FAILURE;
1158
error(0, errno, "sigprocmask");
1159
exitstatus = EX_OSERR;
1006
1160
goto fallback;
1007
1161
}
1008
1162
1018
1172
bool bret = print_out_password(proc->buffer,
1019
1173
proc->buffer_length);
1020
1174
if(not bret){
1021
perror("print_out_password");
1022
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "print_out_password");
1176
exitstatus = EX_IOERR;
1023
1177
}
1024
1178
goto fallback;
1025
1179
}
1026
1180
1027
1181
/* This process has not completed. Does it have any output? */
1028
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 */
1029
1185
/* This process had nothing to say at this time */
1030
1186
proc = proc->next;
1031
1187
continue;
1035
1191
proc->buffer = realloc(proc->buffer, proc->buffer_size
1036
1192
+ (size_t) BUFFER_SIZE);
1037
1193
if(proc->buffer == NULL){
1038
perror("malloc");
1039
exitstatus = EXIT_FAILURE;
1194
error(0, errno, "malloc");
1195
exitstatus = EX_OSERR;
1040
1196
goto fallback;
1041
1197
}
1042
1198
proc->buffer_size += BUFFER_SIZE;
1043
1199
}
1044
1200
/* Read from the process */
1045
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1046
BUFFER_SIZE);
1201
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1202
proc->buffer
1203
+ proc->buffer_length,
1204
BUFFER_SIZE));
1047
1205
if(sret < 0){
1048
1206
/* Read error from this process; ignore the error */
1049
1207
proc = proc->next;
1061
1219
1062
1220
fallback:
1063
1221
1064
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1222
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1223
and exitstatus != EX_OK)){
1065
1224
/* Fallback if all plugins failed, none are found or an error
1066
1225
occured */
1067
1226
bool bret;
1075
1234
}
1076
1235
bret = print_out_password(passwordbuffer, len);
1077
1236
if(not bret){
1078
perror("print_out_password");
1079
exitstatus = EXIT_FAILURE;
1237
error(0, errno, "print_out_password");
1238
exitstatus = EX_IOERR;
1080
1239
}
1081
1240
}
1082
1241
1083
1242
/* Restore old signal handler */
1084
1243
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1085
1244
if(ret == -1){
1086
perror("sigaction");
1087
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "sigaction");
1246
exitstatus = EX_OSERR;
1088
1247
}
1089
1248
1090
1249
if(custom_argv != NULL){
1105
1264
ret = kill(p->pid, SIGTERM);
1106
1265
if(ret == -1 and errno != ESRCH){
1107
1266
/* Set-uid proccesses might not get closed */
1108
perror("kill");
1267
error(0, errno, "kill");
1109
1268
}
1110
1269
}
1111
1270
}
1112
1271
1113
1272
/* Wait for any remaining child processes to terminate */
1114
do{
1273
do {
1115
1274
ret = wait(NULL);
1116
1275
} while(ret >= 0);
1117
1276
if(errno != ECHILD){
1118
perror("wait");
1277
error(0, errno, "wait");
1119
1278
}
1120
1279
1121
1280
free_plugin_list();
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0