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