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