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 951
- compare with another revision
- download diff
- download tarball
- view history from revision 951
- Committer: Teddy Hogeborn
- Date: 2018-08-15 09:26:02 UTC
- Revision ID: teddy@recompile.se-20180815092602-xoyb5s6gf8376i7u
mandos-client: Set system clock if necessary
* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
clock is not set, or set to january 1970, set the system clock to
the more plausible value that is the mtime of the key file. This is
required by GnuPG to be able to import the keys. (We can't pass the
--ignore-time-conflict or the --ignore-valid-from options though
GPGME.)
* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
clock is not set, or set to january 1970, set the system clock to
the more plausible value that is the mtime of the key file. This is
required by GnuPG to be able to import the keys. (We can't pass the
--ignore-time-conflict or the --ignore-valid-from options though
GPGME.)
- 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
7
*
8
* This program is free software: you can redistribute it and/or
9
* modify it under the terms of the GNU General Public License as
10
* published by the Free Software Foundation, either version 3 of the
11
* License, or (at your option) any later version.
12
*
13
* This program is distributed in the hope that it will be useful, but
5
* Copyright © 2008-2018 Teddy Hogeborn
6
* Copyright © 2008-2018 Björn Påhlsson
7
*
8
* This file is part of Mandos.
9
*
10
* Mandos is free software: you can redistribute it and/or modify it
11
* under the terms of the GNU General Public License as published by
12
* the Free Software Foundation, either version 3 of the License, or
13
* (at your option) any later version.
14
*
15
* Mandos is distributed in the hope that it will be useful, but
14
16
* WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
18
* General Public License for more details.
17
19
*
18
20
* You should have received a copy of the GNU General Public License
19
* along with this program. If not, see
20
* <http://www.gnu.org/licenses/>.
21
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
21
22
*
22
* Contact the authors at <mandos@fukt.bsnet.se>.
23
* Contact the authors at <mandos@recompile.se>.
23
24
*/
24
25
25
26
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
26
asprintf() */
27
O_CLOEXEC, pipe2() */
27
28
#include <stddef.h> /* size_t, NULL */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
29
EXIT_SUCCESS, realloc() */
29
#include <stdlib.h> /* malloc(), exit(), EXIT_SUCCESS,
30
realloc() */
30
31
#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() */
32
#include <stdio.h> /* fileno(), fprintf(),
33
stderr, STDOUT_FILENO, fclose() */
34
#include <sys/types.h> /* fstat(), struct stat, waitpid(),
35
WIFEXITED(), WEXITSTATUS(), wait(),
36
pid_t, uid_t, gid_t, getuid(),
37
getgid() */
38
38
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
39
39
FD_SET(), FD_ISSET(), FD_CLR */
40
40
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
41
WEXITSTATUS() */
42
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
41
WEXITSTATUS(), WTERMSIG() */
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,
66
67
*/
67
68
#include <errno.h> /* errno, EBADF */
68
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 */
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++){
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
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){
383
char *tmp;
435
__attribute__((nonnull(3)))
436
error_t parse_opt(int key, char *arg, struct argp_state *state){
437
errno = 0;
384
438
switch(key){
439
char *tmp;
440
intmax_t tmp_id;
385
441
case 'g': /* --global-options */
386
if(arg != NULL){
442
{
387
443
char *plugin_option;
388
444
while((plugin_option = strsep(&arg, ",")) != NULL){
389
if(plugin_option[0] == '\0'){
390
continue;
391
}
392
445
if(not add_argument(getplugin(NULL), plugin_option)){
393
perror("add_argument");
394
return ARGP_ERR_UNKNOWN;
446
break;
395
447
}
396
448
}
449
errno = 0;
397
450
}
398
451
break;
399
452
case 'G': /* --global-env */
400
if(arg == NULL){
401
break;
402
}
403
if(not add_environment(getplugin(NULL), arg, true)){
404
perror("add_environment");
453
if(add_environment(getplugin(NULL), arg, true)){
454
errno = 0;
405
455
}
406
456
break;
407
457
case 'o': /* --options-for */
408
if(arg != NULL){
409
char *plugin_name = strsep(&arg, ":");
410
if(plugin_name[0] == '\0'){
411
break;
412
}
413
char *plugin_option;
414
while((plugin_option = strsep(&arg, ",")) != NULL){
415
if(not add_argument(getplugin(plugin_name), plugin_option)){
416
perror("add_argument");
417
return ARGP_ERR_UNKNOWN;
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;
418
476
}
419
477
}
478
errno = 0;
420
479
}
421
480
break;
422
481
case 'E': /* --env-for */
423
if(arg == NULL){
424
break;
425
}
426
482
{
427
483
char *envdef = strchr(arg, ':');
428
484
if(envdef == NULL){
485
argp_error(state, "No colon in \"%s\"", arg);
486
errno = EINVAL;
429
487
break;
430
488
}
431
489
*envdef = '\0';
432
if(not add_environment(getplugin(arg), envdef+1, true)){
433
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;
434
498
}
435
499
}
436
500
break;
437
501
case 'd': /* --disable */
438
if(arg != NULL){
502
{
439
503
plugin *p = getplugin(arg);
440
if(p == NULL){
441
return ARGP_ERR_UNKNOWN;
504
if(p != NULL){
505
p->disabled = true;
506
errno = 0;
442
507
}
443
p->disabled = true;
444
508
}
445
509
break;
446
510
case 'e': /* --enable */
447
if(arg != NULL){
511
{
448
512
plugin *p = getplugin(arg);
449
if(p == NULL){
450
return ARGP_ERR_UNKNOWN;
513
if(p != NULL){
514
p->disabled = false;
515
errno = 0;
451
516
}
452
p->disabled = false;
453
517
}
454
518
break;
455
519
case 128: /* --plugin-dir */
456
520
free(plugindir);
457
521
plugindir = strdup(arg);
458
if(plugindir == NULL){
459
perror("strdup");
460
}
522
if(plugindir != NULL){
523
errno = 0;
524
}
461
525
break;
462
526
case 129: /* --config-file */
463
527
/* This is already done by parse_opt_config_file() */
464
528
break;
465
529
case 130: /* --userid */
466
errno = 0;
467
tmpmax = strtoimax(arg, &tmp, 10);
530
tmp_id = strtoimax(arg, &tmp, 10);
468
531
if(errno != 0 or tmp == arg or *tmp != '\0'
469
or tmpmax != (uid_t)tmpmax){
470
fprintf(stderr, "Bad user ID number: \"%s\", using %"
471
PRIdMAX "\n", arg, (intmax_t)uid);
472
} else {
473
uid = (uid_t)tmpmax;
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;
474
536
}
537
uid = (uid_t)tmp_id;
538
errno = 0;
475
539
break;
476
540
case 131: /* --groupid */
477
errno = 0;
478
tmpmax = strtoimax(arg, &tmp, 10);
541
tmp_id = strtoimax(arg, &tmp, 10);
479
542
if(errno != 0 or tmp == arg or *tmp != '\0'
480
or tmpmax != (gid_t)tmpmax){
481
fprintf(stderr, "Bad group ID number: \"%s\", using %"
482
PRIdMAX "\n", arg, (intmax_t)gid);
483
} else {
484
gid = (gid_t)tmpmax;
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;
485
547
}
548
gid = (gid_t)tmp_id;
549
errno = 0;
486
550
break;
487
551
case 132: /* --debug */
488
552
debug = true;
489
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;
490
575
/*
491
576
* When adding more options before this line, remember to also add a
492
577
* "case" to the "parse_opt_config_file" function below.
495
580
/* Cryptsetup always passes an argument, which is an empty
496
581
string if "none" was specified in /etc/crypttab. So if
497
582
argument was empty, we ignore it silently. */
498
if(arg[0] != '\0'){
499
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
583
if(arg[0] == '\0'){
584
break;
500
585
}
501
break;
502
case ARGP_KEY_END:
503
break;
586
/* FALLTHROUGH */
504
587
default:
505
588
return ARGP_ERR_UNKNOWN;
506
589
}
507
return 0;
590
return errno; /* Set to 0 at start */
508
591
}
509
592
510
593
/* This option parser is the same as parse_opt() above, except it
512
595
error_t parse_opt_config_file(int key, char *arg,
513
596
__attribute__((unused))
514
597
struct argp_state *state){
598
errno = 0;
515
599
switch(key){
516
600
case 'g': /* --global-options */
517
601
case 'G': /* --global-env */
524
608
case 129: /* --config-file */
525
609
free(argfile);
526
610
argfile = strdup(arg);
527
if(argfile == NULL){
528
perror("strdup");
611
if(argfile != NULL){
612
errno = 0;
529
613
}
530
break;
614
break;
531
615
case 130: /* --userid */
532
616
case 131: /* --groupid */
533
617
case 132: /* --debug */
618
case 133: /* --plugin-helper-dir */
619
case '?': /* --help */
620
case -3: /* --usage */
621
case 'V': /* --version */
534
622
case ARGP_KEY_ARG:
535
case ARGP_KEY_END:
536
623
break;
537
624
default:
538
625
return ARGP_ERR_UNKNOWN;
539
626
}
540
return 0;
627
return errno;
541
628
}
542
629
543
630
struct argp argp = { .options = options,
547
634
548
635
/* Parse using parse_opt_config_file() in order to get the custom
549
636
config file location, if any. */
550
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
551
if(ret == ARGP_ERR_UNKNOWN){
552
fprintf(stderr, "Unknown error while parsing arguments\n");
553
exitstatus = EXIT_FAILURE;
637
ret = argp_parse(&argp, argc, argv,
638
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
639
NULL, NULL);
640
switch(ret){
641
case 0:
642
break;
643
case ENOMEM:
644
default:
645
errno = ret;
646
error(0, errno, "argp_parse");
647
exitstatus = EX_OSERR;
648
goto fallback;
649
case EINVAL:
650
exitstatus = EX_USAGE;
554
651
goto fallback;
555
652
}
556
653
562
659
conffp = fopen(AFILE, "r");
563
660
} else {
564
661
conffp = fopen(argfile, "r");
565
}
662
}
566
663
if(conffp != NULL){
567
664
char *org_line = NULL;
568
665
char *p, *arg, *new_arg, *line;
573
670
custom_argc = 1;
574
671
custom_argv = malloc(sizeof(char*) * 2);
575
672
if(custom_argv == NULL){
576
perror("malloc");
577
exitstatus = EXIT_FAILURE;
673
error(0, errno, "malloc");
674
exitstatus = EX_OSERR;
578
675
goto fallback;
579
676
}
580
677
custom_argv[0] = argv[0];
596
693
}
597
694
new_arg = strdup(p);
598
695
if(new_arg == NULL){
599
perror("strdup");
600
exitstatus = EXIT_FAILURE;
696
error(0, errno, "strdup");
697
exitstatus = EX_OSERR;
601
698
free(org_line);
602
699
goto fallback;
603
700
}
604
701
605
702
custom_argc += 1;
606
custom_argv = realloc(custom_argv, sizeof(char *)
607
* ((unsigned int) custom_argc + 1));
608
if(custom_argv == NULL){
609
perror("realloc");
610
exitstatus = EXIT_FAILURE;
611
free(org_line);
612
goto fallback;
703
{
704
char **new_argv = realloc(custom_argv, sizeof(char *)
705
* ((size_t)custom_argc + 1));
706
if(new_argv == NULL){
707
error(0, errno, "realloc");
708
exitstatus = EX_OSERR;
709
free(new_arg);
710
free(org_line);
711
goto fallback;
712
} else {
713
custom_argv = new_argv;
714
}
613
715
}
614
716
custom_argv[custom_argc-1] = new_arg;
615
custom_argv[custom_argc] = NULL;
717
custom_argv[custom_argc] = NULL;
616
718
}
617
719
}
720
do {
721
ret = fclose(conffp);
722
} while(ret == EOF and errno == EINTR);
723
if(ret == EOF){
724
error(0, errno, "fclose");
725
exitstatus = EX_IOERR;
726
goto fallback;
727
}
618
728
free(org_line);
619
729
} else {
620
730
/* Check for harmful errors and go to fallback. Other errors might
621
731
not affect opening plugins */
622
732
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
623
perror("fopen");
624
exitstatus = EXIT_FAILURE;
733
error(0, errno, "fopen");
734
exitstatus = EX_OSERR;
625
735
goto fallback;
626
736
}
627
737
}
628
/* If there was any arguments from configuration file,
629
pass them to parser as command arguments */
738
/* If there were any arguments from the configuration file, pass
739
them to parser as command line arguments */
630
740
if(custom_argv != NULL){
631
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
632
0, NULL);
633
if(ret == ARGP_ERR_UNKNOWN){
634
fprintf(stderr, "Unknown error while parsing arguments\n");
635
exitstatus = EXIT_FAILURE;
741
ret = argp_parse(&argp, custom_argc, custom_argv,
742
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
743
NULL, NULL);
744
switch(ret){
745
case 0:
746
break;
747
case ENOMEM:
748
default:
749
errno = ret;
750
error(0, errno, "argp_parse");
751
exitstatus = EX_OSERR;
752
goto fallback;
753
case EINVAL:
754
exitstatus = EX_CONFIG;
636
755
goto fallback;
637
756
}
638
757
}
639
758
640
759
/* Parse actual command line arguments, to let them override the
641
760
config file */
642
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
643
if(ret == ARGP_ERR_UNKNOWN){
644
fprintf(stderr, "Unknown error while parsing arguments\n");
645
exitstatus = EXIT_FAILURE;
646
goto fallback;
761
ret = argp_parse(&argp, argc, argv,
762
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
763
NULL, NULL);
764
switch(ret){
765
case 0:
766
break;
767
case ENOMEM:
768
default:
769
errno = ret;
770
error(0, errno, "argp_parse");
771
exitstatus = EX_OSERR;
772
goto fallback;
773
case EINVAL:
774
exitstatus = EX_USAGE;
775
goto fallback;
776
}
777
778
{
779
char *pluginhelperenv;
780
bool bret = true;
781
ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
782
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
783
if(ret != -1){
784
bret = add_environment(getplugin(NULL), pluginhelperenv, true);
785
}
786
if(ret == -1 or not bret){
787
error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
788
" environment variable to \"%s\" for all plugins\n",
789
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
790
}
791
if(ret != -1){
792
free(pluginhelperenv);
793
}
647
794
}
648
795
649
796
if(debug){
650
for(plugin *p = plugin_list; p != NULL; p=p->next){
797
for(plugin *p = plugin_list; p != NULL; p = p->next){
651
798
fprintf(stderr, "Plugin: %s has %d arguments\n",
652
799
p->name ? p->name : "Global", p->argc - 1);
653
800
for(char **a = p->argv; *a != NULL; a++){
660
807
}
661
808
}
662
809
663
/* Strip permissions down to nobody */
664
setgid(gid);
810
if(getuid() == 0){
811
/* Work around Debian bug #633582:
812
<https://bugs.debian.org/633582> */
813
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
814
if(plugindir_fd == -1){
815
if(errno != ENOENT){
816
error(0, errno, "open(\"" PDIR "\")");
817
}
818
} else {
819
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
820
if(ret == -1){
821
error(0, errno, "fstat");
822
} else {
823
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
824
ret = fchown(plugindir_fd, uid, gid);
825
if(ret == -1){
826
error(0, errno, "fchown");
827
}
828
}
829
}
830
close(plugindir_fd);
831
}
832
}
833
834
/* Lower permissions */
835
ret = setgid(gid);
665
836
if(ret == -1){
666
perror("setgid");
837
error(0, errno, "setgid");
667
838
}
668
839
ret = setuid(uid);
669
840
if(ret == -1){
670
perror("setuid");
671
}
672
673
if(plugindir == NULL){
674
dir = opendir(PDIR);
675
} else {
676
dir = opendir(plugindir);
677
}
678
679
if(dir == NULL){
680
perror("Could not open plugin dir");
681
exitstatus = EXIT_FAILURE;
682
goto fallback;
683
}
684
685
/* Set the FD_CLOEXEC flag on the directory, if possible */
841
error(0, errno, "setuid");
842
}
843
844
/* Open plugin directory with close_on_exec flag */
686
845
{
687
int dir_fd = dirfd(dir);
688
if(dir_fd >= 0){
689
ret = set_cloexec_flag(dir_fd);
690
if(ret < 0){
691
perror("set_cloexec_flag");
692
exitstatus = EXIT_FAILURE;
693
goto fallback;
846
dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
847
#ifdef O_CLOEXEC
848
O_CLOEXEC
849
#else /* not O_CLOEXEC */
850
0
851
#endif /* not O_CLOEXEC */
852
);
853
if(dir_fd == -1){
854
error(0, errno, "Could not open plugin dir");
855
exitstatus = EX_UNAVAILABLE;
856
goto fallback;
857
}
858
859
#ifndef O_CLOEXEC
860
/* Set the FD_CLOEXEC flag on the directory */
861
ret = set_cloexec_flag(dir_fd);
862
if(ret < 0){
863
error(0, errno, "set_cloexec_flag");
864
exitstatus = EX_OSERR;
865
goto fallback;
866
}
867
#endif /* O_CLOEXEC */
868
}
869
870
int good_name(const struct dirent * const dirent){
871
const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
872
"*.dpkg-old", "*.dpkg-bak",
873
"*.dpkg-divert", NULL };
874
#ifdef __GNUC__
875
#pragma GCC diagnostic push
876
#pragma GCC diagnostic ignored "-Wcast-qual"
877
#endif
878
for(const char **pat = (const char **)patterns;
879
*pat != NULL; pat++){
880
#ifdef __GNUC__
881
#pragma GCC diagnostic pop
882
#endif
883
if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
884
!= FNM_NOMATCH){
885
if(debug){
886
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
887
" matching pattern %s\n", dirent->d_name, *pat);
888
}
889
return 0;
694
890
}
695
891
}
892
return 1;
893
}
894
895
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
896
alphasort);
897
if(numplugins == -1){
898
error(0, errno, "Could not scan plugin dir");
899
direntries = NULL;
900
exitstatus = EX_OSERR;
901
goto fallback;
696
902
}
697
903
698
904
FD_ZERO(&rfds_all);
699
905
700
906
/* Read and execute any executable in the plugin directory*/
701
while(true){
702
dirst = readdir(dir);
703
704
/* All directory entries have been processed */
705
if(dirst == NULL){
706
if(errno == EBADF){
707
perror("readdir");
708
exitstatus = EXIT_FAILURE;
709
goto fallback;
710
}
711
break;
712
}
713
714
d_name_len = strlen(dirst->d_name);
715
716
/* Ignore dotfiles, backup files and other junk */
717
{
718
bool bad_name = false;
719
720
const char const *bad_prefixes[] = { ".", "#", NULL };
721
722
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
723
".dpkg-old",
724
".dpkg-bak",
725
".dpkg-divert", NULL };
726
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
727
size_t pre_len = strlen(*pre);
728
if((d_name_len >= pre_len)
729
and strncmp((dirst->d_name), *pre, pre_len) == 0){
730
if(debug){
731
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
732
" with bad prefix %s\n", dirst->d_name, *pre);
733
}
734
bad_name = true;
735
break;
736
}
737
}
738
if(bad_name){
739
continue;
740
}
741
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
742
size_t suf_len = strlen(*suf);
743
if((d_name_len >= suf_len)
744
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
745
== 0)){
746
if(debug){
747
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
748
" with bad suffix %s\n", dirst->d_name, *suf);
749
}
750
bad_name = true;
751
break;
752
}
753
}
754
755
if(bad_name){
756
continue;
757
}
758
}
759
760
char *filename;
761
if(plugindir == NULL){
762
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
763
} else {
764
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
765
}
766
if(ret < 0){
767
perror("asprintf");
907
for(int i = 0; i < numplugins; i++){
908
909
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
910
if(plugin_fd == -1){
911
error(0, errno, "Could not open plugin");
912
free(direntries[i]);
768
913
continue;
769
914
}
770
771
ret = stat(filename, &st);
915
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
772
916
if(ret == -1){
773
perror("stat");
774
free(filename);
917
error(0, errno, "stat");
918
close(plugin_fd);
919
free(direntries[i]);
775
920
continue;
776
921
}
777
922
778
923
/* Ignore non-executable files */
779
if(not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
924
if(not S_ISREG(st.st_mode)
925
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
926
X_OK, 0)) != 0)){
780
927
if(debug){
781
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
782
" with bad type or mode\n", filename);
928
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
929
" with bad type or mode\n",
930
plugindir != NULL ? plugindir : PDIR,
931
direntries[i]->d_name);
783
932
}
784
free(filename);
933
close(plugin_fd);
934
free(direntries[i]);
785
935
continue;
786
936
}
787
937
788
plugin *p = getplugin(dirst->d_name);
938
plugin *p = getplugin(direntries[i]->d_name);
789
939
if(p == NULL){
790
perror("getplugin");
791
free(filename);
940
error(0, errno, "getplugin");
941
close(plugin_fd);
942
free(direntries[i]);
792
943
continue;
793
944
}
794
945
if(p->disabled){
795
946
if(debug){
796
947
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
797
dirst->d_name);
948
direntries[i]->d_name);
798
949
}
799
free(filename);
950
close(plugin_fd);
951
free(direntries[i]);
800
952
continue;
801
953
}
802
954
{
805
957
if(g != NULL){
806
958
for(char **a = g->argv + 1; *a != NULL; a++){
807
959
if(not add_argument(p, *a)){
808
perror("add_argument");
960
error(0, errno, "add_argument");
809
961
}
810
962
}
811
963
/* Add global environment variables */
812
964
for(char **e = g->environ; *e != NULL; e++){
813
965
if(not add_environment(p, *e, false)){
814
perror("add_environment");
966
error(0, errno, "add_environment");
815
967
}
816
968
}
817
969
}
818
970
}
819
/* If this plugin has any environment variables, we will call
820
using execve and need to duplicate the environment from this
821
process, too. */
971
/* If this plugin has any environment variables, we need to
972
duplicate the environment from this process, too. */
822
973
if(p->environ[0] != NULL){
823
974
for(char **e = environ; *e != NULL; e++){
824
975
if(not add_environment(p, *e, false)){
825
perror("add_environment");
976
error(0, errno, "add_environment");
826
977
}
827
978
}
828
979
}
829
980
830
981
int pipefd[2];
831
ret = pipe(pipefd);
982
#ifndef O_CLOEXEC
983
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
984
#else /* O_CLOEXEC */
985
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
986
#endif /* O_CLOEXEC */
832
987
if(ret == -1){
833
perror("pipe");
834
exitstatus = EXIT_FAILURE;
835
goto fallback;
836
}
988
error(0, errno, "pipe");
989
exitstatus = EX_OSERR;
990
free(direntries[i]);
991
goto fallback;
992
}
993
if(pipefd[0] >= FD_SETSIZE){
994
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
995
FD_SETSIZE);
996
close(pipefd[0]);
997
close(pipefd[1]);
998
exitstatus = EX_OSERR;
999
free(direntries[i]);
1000
goto fallback;
1001
}
1002
#ifndef O_CLOEXEC
837
1003
/* Ask OS to automatic close the pipe on exec */
838
1004
ret = set_cloexec_flag(pipefd[0]);
839
1005
if(ret < 0){
840
perror("set_cloexec_flag");
841
exitstatus = EXIT_FAILURE;
1006
error(0, errno, "set_cloexec_flag");
1007
close(pipefd[0]);
1008
close(pipefd[1]);
1009
exitstatus = EX_OSERR;
1010
free(direntries[i]);
842
1011
goto fallback;
843
1012
}
844
1013
ret = set_cloexec_flag(pipefd[1]);
845
1014
if(ret < 0){
846
perror("set_cloexec_flag");
847
exitstatus = EXIT_FAILURE;
1015
error(0, errno, "set_cloexec_flag");
1016
close(pipefd[0]);
1017
close(pipefd[1]);
1018
exitstatus = EX_OSERR;
1019
free(direntries[i]);
848
1020
goto fallback;
849
1021
}
1022
#endif /* not O_CLOEXEC */
850
1023
/* Block SIGCHLD until process is safely in process list */
851
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1024
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1025
&sigchld_action.sa_mask,
1026
NULL));
852
1027
if(ret < 0){
853
perror("sigprocmask");
854
exitstatus = EXIT_FAILURE;
1028
error(0, errno, "sigprocmask");
1029
exitstatus = EX_OSERR;
1030
free(direntries[i]);
855
1031
goto fallback;
856
1032
}
857
1033
/* Starting a new process to be watched */
858
pid_t pid = fork();
1034
pid_t pid;
1035
do {
1036
pid = fork();
1037
} while(pid == -1 and errno == EINTR);
859
1038
if(pid == -1){
860
perror("fork");
861
exitstatus = EXIT_FAILURE;
1039
error(0, errno, "fork");
1040
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1041
&sigchld_action.sa_mask, NULL));
1042
close(pipefd[0]);
1043
close(pipefd[1]);
1044
exitstatus = EX_OSERR;
1045
free(direntries[i]);
862
1046
goto fallback;
863
1047
}
864
1048
if(pid == 0){
865
1049
/* this is the child process */
866
1050
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
867
1051
if(ret < 0){
868
perror("sigaction");
869
_exit(EXIT_FAILURE);
1052
error(0, errno, "sigaction");
1053
_exit(EX_OSERR);
870
1054
}
871
1055
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
872
1056
if(ret < 0){
873
perror("sigprocmask");
874
_exit(EXIT_FAILURE);
1057
error(0, errno, "sigprocmask");
1058
_exit(EX_OSERR);
875
1059
}
876
1060
877
1061
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
878
1062
if(ret == -1){
879
perror("dup2");
880
_exit(EXIT_FAILURE);
1063
error(0, errno, "dup2");
1064
_exit(EX_OSERR);
881
1065
}
882
1066
883
if(dirfd(dir) < 0){
884
/* If dir has no file descriptor, we could not set FD_CLOEXEC
885
above and must now close it manually here. */
886
closedir(dir);
887
}
888
if(p->environ[0] == NULL){
889
if(execv(filename, p->argv) < 0){
890
perror("execv");
891
_exit(EXIT_FAILURE);
892
}
893
} else {
894
if(execve(filename, p->argv, p->environ) < 0){
895
perror("execve");
896
_exit(EXIT_FAILURE);
897
}
1067
if(fexecve(plugin_fd, p->argv,
1068
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1069
error(0, errno, "fexecve for %s/%s",
1070
plugindir != NULL ? plugindir : PDIR,
1071
direntries[i]->d_name);
1072
_exit(EX_OSERR);
898
1073
}
899
1074
/* no return */
900
1075
}
901
1076
/* Parent process */
902
1077
close(pipefd[1]); /* Close unused write end of pipe */
903
free(filename);
904
plugin *new_plugin = getplugin(dirst->d_name);
1078
close(plugin_fd);
1079
plugin *new_plugin = getplugin(direntries[i]->d_name);
905
1080
if(new_plugin == NULL){
906
perror("getplugin");
907
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1081
error(0, errno, "getplugin");
1082
ret = (int)(TEMP_FAILURE_RETRY
1083
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1084
NULL)));
908
1085
if(ret < 0){
909
perror("sigprocmask");
1086
error(0, errno, "sigprocmask");
910
1087
}
911
exitstatus = EXIT_FAILURE;
1088
exitstatus = EX_OSERR;
1089
free(direntries[i]);
912
1090
goto fallback;
913
1091
}
1092
free(direntries[i]);
914
1093
915
1094
new_plugin->pid = pid;
916
1095
new_plugin->fd = pipefd[0];
917
1096
918
1097
/* Unblock SIGCHLD so signal handler can be run if this process
919
1098
has already completed */
920
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1099
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1100
&sigchld_action.sa_mask,
1101
NULL));
921
1102
if(ret < 0){
922
perror("sigprocmask");
923
exitstatus = EXIT_FAILURE;
1103
error(0, errno, "sigprocmask");
1104
exitstatus = EX_OSERR;
924
1105
goto fallback;
925
1106
}
926
1107
931
1112
}
932
1113
}
933
1114
934
closedir(dir);
935
dir = NULL;
1115
free(direntries);
1116
direntries = NULL;
1117
close(dir_fd);
1118
dir_fd = -1;
936
1119
free_plugin(getplugin(NULL));
937
1120
938
1121
for(plugin *p = plugin_list; p != NULL; p = p->next){
950
1133
while(plugin_list){
951
1134
fd_set rfds = rfds_all;
952
1135
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
953
if(select_ret == -1){
954
perror("select");
955
exitstatus = EXIT_FAILURE;
1136
if(select_ret == -1 and errno != EINTR){
1137
error(0, errno, "select");
1138
exitstatus = EX_OSERR;
956
1139
goto fallback;
957
1140
}
958
1141
/* OK, now either a process completed, or something can be read
973
1156
WEXITSTATUS(proc->status));
974
1157
} else if(WIFSIGNALED(proc->status)){
975
1158
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
976
" signal %d\n", proc->name,
1159
" signal %d: %s\n", proc->name,
977
1160
(intmax_t) (proc->pid),
978
WTERMSIG(proc->status));
979
} else if(WCOREDUMP(proc->status)){
980
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
981
" core\n", proc->name, (intmax_t) (proc->pid));
1161
WTERMSIG(proc->status),
1162
strsignal(WTERMSIG(proc->status)));
982
1163
}
983
1164
}
984
1165
986
1167
FD_CLR(proc->fd, &rfds_all);
987
1168
988
1169
/* Block signal while modifying process_list */
989
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1170
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1171
(SIG_BLOCK,
1172
&sigchld_action.sa_mask,
1173
NULL));
990
1174
if(ret < 0){
991
perror("sigprocmask");
992
exitstatus = EXIT_FAILURE;
1175
error(0, errno, "sigprocmask");
1176
exitstatus = EX_OSERR;
993
1177
goto fallback;
994
1178
}
995
1179
998
1182
proc = next_plugin;
999
1183
1000
1184
/* We are done modifying process list, so unblock signal */
1001
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1002
NULL);
1185
ret = (int)(TEMP_FAILURE_RETRY
1186
(sigprocmask(SIG_UNBLOCK,
1187
&sigchld_action.sa_mask, NULL)));
1003
1188
if(ret < 0){
1004
perror("sigprocmask");
1005
exitstatus = EXIT_FAILURE;
1189
error(0, errno, "sigprocmask");
1190
exitstatus = EX_OSERR;
1006
1191
goto fallback;
1007
1192
}
1008
1193
1018
1203
bool bret = print_out_password(proc->buffer,
1019
1204
proc->buffer_length);
1020
1205
if(not bret){
1021
perror("print_out_password");
1022
exitstatus = EXIT_FAILURE;
1206
error(0, errno, "print_out_password");
1207
exitstatus = EX_IOERR;
1023
1208
}
1024
1209
goto fallback;
1025
1210
}
1032
1217
}
1033
1218
/* Before reading, make the process' data buffer large enough */
1034
1219
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1035
proc->buffer = realloc(proc->buffer, proc->buffer_size
1036
+ (size_t) BUFFER_SIZE);
1037
if(proc->buffer == NULL){
1038
perror("malloc");
1039
exitstatus = EXIT_FAILURE;
1220
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1221
+ (size_t) BUFFER_SIZE);
1222
if(new_buffer == NULL){
1223
error(0, errno, "malloc");
1224
exitstatus = EX_OSERR;
1040
1225
goto fallback;
1041
1226
}
1227
proc->buffer = new_buffer;
1042
1228
proc->buffer_size += BUFFER_SIZE;
1043
1229
}
1044
1230
/* Read from the process */
1045
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1046
BUFFER_SIZE);
1231
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1232
proc->buffer
1233
+ proc->buffer_length,
1234
BUFFER_SIZE));
1047
1235
if(sret < 0){
1048
1236
/* Read error from this process; ignore the error */
1049
1237
proc = proc->next;
1061
1249
1062
1250
fallback:
1063
1251
1064
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1252
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1253
and exitstatus != EX_OK)){
1065
1254
/* Fallback if all plugins failed, none are found or an error
1066
1255
occured */
1067
1256
bool bret;
1075
1264
}
1076
1265
bret = print_out_password(passwordbuffer, len);
1077
1266
if(not bret){
1078
perror("print_out_password");
1079
exitstatus = EXIT_FAILURE;
1267
error(0, errno, "print_out_password");
1268
exitstatus = EX_IOERR;
1080
1269
}
1081
1270
}
1082
1271
1083
1272
/* Restore old signal handler */
1084
1273
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1085
1274
if(ret == -1){
1086
perror("sigaction");
1087
exitstatus = EXIT_FAILURE;
1275
error(0, errno, "sigaction");
1276
exitstatus = EX_OSERR;
1088
1277
}
1089
1278
1090
1279
if(custom_argv != NULL){
1094
1283
free(custom_argv);
1095
1284
}
1096
1285
1097
if(dir != NULL){
1098
closedir(dir);
1286
free(direntries);
1287
1288
if(dir_fd != -1){
1289
close(dir_fd);
1099
1290
}
1100
1291
1101
1292
/* Kill the processes */
1105
1296
ret = kill(p->pid, SIGTERM);
1106
1297
if(ret == -1 and errno != ESRCH){
1107
1298
/* Set-uid proccesses might not get closed */
1108
perror("kill");
1299
error(0, errno, "kill");
1109
1300
}
1110
1301
}
1111
1302
}
1112
1303
1113
1304
/* Wait for any remaining child processes to terminate */
1114
do{
1305
do {
1115
1306
ret = wait(NULL);
1116
1307
} while(ret >= 0);
1117
1308
if(errno != ECHILD){
1118
perror("wait");
1309
error(0, errno, "wait");
1119
1310
}
1120
1311
1121
1312
free_plugin_list();
1122
1313
1123
1314
free(plugindir);
1315
free(pluginhelperdir);
1124
1316
free(argfile);
1125
1317
1126
1318
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0