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