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