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 777
- compare with another revision
- download diff
- download tarball
- view history from revision 777
- Committer: Teddy Hogeborn
- Date: 2015-07-20 03:03:33 UTC
- Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.
The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string. This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:
SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256
* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
(/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.
The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string. This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:
SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256
* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
(/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.
- files added:
- DBUS-API
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files renamed:
- mandos-list => mandos-ctl
- files modified:
- .bzrignore
added
removed
plugin-runner.c
1
/* -*- coding: utf-8 -*- */
1
/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
3
* Mandos plugin runner - Run Mandos plugins
4
4
*
5
* Copyright © 2008,2009 Teddy Hogeborn
6
* Copyright © 2008,2009 Björn Påhlsson
5
* Copyright © 2008-2014 Teddy Hogeborn
6
* Copyright © 2008-2014 Björn Påhlsson
7
7
*
8
8
* This program is free software: you can redistribute it and/or
9
9
* modify it under the terms of the GNU General Public License as
19
19
* along with this program. If not, see
20
20
* <http://www.gnu.org/licenses/>.
21
21
*
22
* Contact the authors at <mandos@fukt.bsnet.se>.
22
* Contact the authors at <mandos@recompile.se>.
23
23
*/
24
24
25
25
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
26
asprintf() */
26
O_CLOEXEC, pipe2() */
27
27
#include <stddef.h> /* size_t, NULL */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
29
EXIT_SUCCESS, realloc() */
28
#include <stdlib.h> /* malloc(), exit(), EXIT_SUCCESS,
29
realloc() */
30
30
#include <stdbool.h> /* bool, true, false */
31
#include <stdio.h> /* perror, fileno(), fprintf(),
32
stderr, STDOUT_FILENO */
33
#include <sys/types.h> /* DIR, opendir(), stat(), struct
34
stat, waitpid(), WIFEXITED(),
35
WEXITSTATUS(), wait(), pid_t,
36
uid_t, gid_t, getuid(), getgid(),
37
dirfd() */
31
#include <stdio.h> /* fileno(), fprintf(),
32
stderr, STDOUT_FILENO, fclose() */
33
#include <sys/types.h> /* fstat(), struct stat, waitpid(),
34
WIFEXITED(), WEXITSTATUS(), wait(),
35
pid_t, uid_t, gid_t, getuid(),
36
getgid() */
38
37
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
39
38
FD_SET(), FD_ISSET(), FD_CLR */
40
39
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
41
WEXITSTATUS() */
42
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
40
WEXITSTATUS(), WTERMSIG(),
41
WCOREDUMP() */
42
#include <sys/stat.h> /* struct stat, fstat(), S_ISREG() */
43
43
#include <iso646.h> /* and, or, not */
44
#include <dirent.h> /* DIR, struct dirent, opendir(),
45
readdir(), closedir(), dirfd() */
46
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
47
fcntl(), setuid(), setgid(),
48
F_GETFD, F_SETFD, FD_CLOEXEC,
49
access(), pipe(), fork(), close()
50
dup2(), STDOUT_FILENO, _exit(),
51
execv(), write(), read(),
52
close() */
44
#include <dirent.h> /* struct dirent, scandirat() */
45
#include <unistd.h> /* fcntl(), F_GETFD, F_SETFD,
46
FD_CLOEXEC, write(), STDOUT_FILENO,
47
struct stat, fstat(), close(),
48
setgid(), setuid(), S_ISREG(),
49
faccessat() pipe2(), fork(),
50
_exit(), dup2(), fexecve(), read()
51
*/
53
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
54
FD_CLOEXEC */
55
#include <string.h> /* strsep, strlen(), asprintf() */
53
FD_CLOEXEC, openat(), scandirat(),
54
pipe2() */
55
#include <string.h> /* strsep, strlen(), strsignal(),
56
strcmp(), strncmp() */
56
57
#include <errno.h> /* errno */
57
58
#include <argp.h> /* struct argp_option, struct
58
59
argp_state, struct argp,
62
63
#include <signal.h> /* struct sigaction, sigemptyset(),
63
64
sigaddset(), sigaction(),
64
65
sigprocmask(), SIG_BLOCK, SIGCHLD,
65
SIG_UNBLOCK, kill() */
66
SIG_UNBLOCK, kill(), sig_atomic_t
67
*/
66
68
#include <errno.h> /* errno, EBADF */
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() */
67
75
68
76
#define BUFFER_SIZE 256
69
77
70
78
#define PDIR "/lib/mandos/plugins.d"
79
#define PHDIR "/lib/mandos/plugin-helpers"
71
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
72
81
73
82
const char *argp_program_version = "plugin-runner " VERSION;
74
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
83
const char *argp_program_bug_address = "<mandos@recompile.se>";
75
84
76
85
typedef struct plugin{
77
86
char *name; /* can be NULL or any plugin name */
80
89
char **environ;
81
90
int envc;
82
91
bool disabled;
83
92
84
93
/* Variables used for running processes*/
85
94
pid_t pid;
86
95
int fd;
88
97
size_t buffer_size;
89
98
size_t buffer_length;
90
99
bool eof;
91
volatile bool completed;
92
volatile int status;
100
volatile sig_atomic_t completed;
101
int status;
93
102
struct plugin *next;
94
103
} plugin;
95
104
97
106
98
107
/* Gets an existing plugin based on name,
99
108
or if none is found, creates a new one */
109
__attribute__((warn_unused_result))
100
110
static plugin *getplugin(char *name){
101
/* Check for exiting plugin with that name */
111
/* Check for existing plugin with that name */
102
112
for(plugin *p = plugin_list; p != NULL; p = p->next){
103
113
if((p->name == name)
104
114
or (p->name and name and (strcmp(p->name, name) == 0))){
106
116
}
107
117
}
108
118
/* Create a new plugin */
109
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);
110
123
if(new_plugin == NULL){
111
124
return NULL;
112
125
}
113
126
char *copy_name = NULL;
114
127
if(name != NULL){
115
copy_name = strdup(name);
128
do {
129
copy_name = strdup(name);
130
} while(copy_name == NULL and errno == EINTR);
116
131
if(copy_name == NULL){
132
int e = errno;
133
free(new_plugin);
134
errno = e;
117
135
return NULL;
118
136
}
119
137
}
120
138
121
*new_plugin = (plugin) { .name = copy_name,
122
.argc = 1,
123
.disabled = false,
124
.next = plugin_list };
139
*new_plugin = (plugin){ .name = copy_name,
140
.argc = 1,
141
.disabled = false,
142
.next = plugin_list };
125
143
126
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);
127
147
if(new_plugin->argv == NULL){
148
int e = errno;
128
149
free(copy_name);
129
150
free(new_plugin);
151
errno = e;
130
152
return NULL;
131
153
}
132
154
new_plugin->argv[0] = copy_name;
133
155
new_plugin->argv[1] = NULL;
134
156
135
new_plugin->environ = malloc(sizeof(char *));
157
do {
158
new_plugin->environ = malloc(sizeof(char *));
159
} while(new_plugin->environ == NULL and errno == EINTR);
136
160
if(new_plugin->environ == NULL){
161
int e = errno;
137
162
free(copy_name);
138
163
free(new_plugin->argv);
139
164
free(new_plugin);
165
errno = e;
140
166
return NULL;
141
167
}
142
168
new_plugin->environ[0] = NULL;
147
173
}
148
174
149
175
/* Helper function for add_argument and add_environment */
176
__attribute__((nonnull, warn_unused_result))
150
177
static bool add_to_char_array(const char *new, char ***array,
151
178
int *len){
152
179
/* Resize the pointed-to array to hold one more pointer */
153
*array = realloc(*array, sizeof(char *)
154
* (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);
155
185
/* Malloc check */
156
if(*array == NULL){
186
if(new_array == NULL){
157
187
return false;
158
188
}
189
*array = new_array;
159
190
/* Make a copy of the new string */
160
char *copy = strdup(new);
191
char *copy;
192
do {
193
copy = strdup(new);
194
} while(copy == NULL and errno == EINTR);
161
195
if(copy == NULL){
162
196
return false;
163
197
}
170
204
}
171
205
172
206
/* Add to a plugin's argument vector */
207
__attribute__((nonnull(2), warn_unused_result))
173
208
static bool add_argument(plugin *p, const char *arg){
174
209
if(p == NULL){
175
210
return false;
178
213
}
179
214
180
215
/* Add to a plugin's environment */
216
__attribute__((nonnull(2), warn_unused_result))
181
217
static bool add_environment(plugin *p, const char *def, bool replace){
182
218
if(p == NULL){
183
219
return false;
185
221
/* namelen = length of name of environment variable */
186
222
size_t namelen = (size_t)(strchrnul(def, '=') - def);
187
223
/* Search for this environment variable */
188
for(char **e = p->environ; *e != NULL; e++){
189
if(strncmp(*e, def, namelen + 1) == 0){
224
for(char **envdef = p->environ; *envdef != NULL; envdef++){
225
if(strncmp(*envdef, def, namelen + 1) == 0){
190
226
/* It already exists */
191
227
if(replace){
192
char *new = realloc(*e, strlen(def) + 1);
193
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){
194
233
return false;
195
234
}
196
*e = new;
197
strcpy(*e, def);
235
*envdef = new_envdef;
236
strcpy(*envdef, def);
198
237
}
199
238
return true;
200
239
}
202
241
return add_to_char_array(def, &(p->environ), &(p->envc));
203
242
}
204
243
244
#ifndef O_CLOEXEC
205
245
/*
206
246
* Based on the example in the GNU LibC manual chapter 13.13 "File
207
247
* Descriptor Flags".
208
* *Note File Descriptor Flags:(libc)Descriptor Flags.
248
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
209
249
*/
250
__attribute__((warn_unused_result))
210
251
static int set_cloexec_flag(int fd){
211
int ret = fcntl(fd, F_GETFD, 0);
252
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
212
253
/* If reading the flags failed, return error indication now. */
213
254
if(ret < 0){
214
255
return ret;
215
256
}
216
257
/* Store modified flag word in the descriptor. */
217
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
258
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
259
ret | FD_CLOEXEC));
218
260
}
261
#endif /* not O_CLOEXEC */
219
262
220
263
221
264
/* Mark processes as completed when they exit, and save their exit
222
265
status. */
223
266
static void handle_sigchld(__attribute__((unused)) int sig){
267
int old_errno = errno;
224
268
while(true){
225
269
plugin *proc = plugin_list;
226
270
int status;
230
274
break;
231
275
}
232
276
if(pid == -1){
233
if(errno != ECHILD){
234
perror("waitpid");
277
if(errno == ECHILD){
278
/* No child processes */
279
break;
235
280
}
236
/* No child processes */
237
break;
281
error(0, errno, "waitpid");
238
282
}
239
283
240
284
/* A child exited, find it in process_list */
246
290
continue;
247
291
}
248
292
proc->status = status;
249
proc->completed = true;
293
proc->completed = 1;
250
294
}
295
errno = old_errno;
251
296
}
252
297
253
298
/* Prints out a password to stdout */
299
__attribute__((nonnull, warn_unused_result))
254
300
static bool print_out_password(const char *buffer, size_t length){
255
301
ssize_t ret;
256
302
for(size_t written = 0; written < length; written += (size_t)ret){
264
310
}
265
311
266
312
/* Removes and free a plugin from the plugin list */
313
__attribute__((nonnull))
267
314
static void free_plugin(plugin *plugin_node){
268
315
269
316
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
275
322
}
276
323
free(plugin_node->environ);
277
324
free(plugin_node->buffer);
278
325
279
326
/* Removes the plugin from the singly-linked list */
280
327
if(plugin_node == plugin_list){
281
328
/* First one - simple */
301
348
302
349
int main(int argc, char *argv[]){
303
350
char *plugindir = NULL;
351
char *pluginhelperdir = NULL;
304
352
char *argfile = NULL;
305
353
FILE *conffp;
306
size_t d_name_len;
307
DIR *dir = NULL;
308
struct dirent *dirst;
354
struct dirent **direntries = NULL;
309
355
struct stat st;
310
356
fd_set rfds_all;
311
357
int ret, maxfd = 0;
319
365
.sa_flags = SA_NOCLDSTOP };
320
366
char **custom_argv = NULL;
321
367
int custom_argc = 0;
368
int dir_fd = -1;
322
369
323
370
/* Establish a signal handler */
324
371
sigemptyset(&sigchld_action.sa_mask);
325
372
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
326
373
if(ret == -1){
327
perror("sigaddset");
328
exitstatus = EXIT_FAILURE;
374
error(0, errno, "sigaddset");
375
exitstatus = EX_OSERR;
329
376
goto fallback;
330
377
}
331
378
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
332
379
if(ret == -1){
333
perror("sigaction");
334
exitstatus = EXIT_FAILURE;
380
error(0, errno, "sigaction");
381
exitstatus = EX_OSERR;
335
382
goto fallback;
336
383
}
337
384
369
416
.doc = "Group ID the plugins will run as", .group = 3 },
370
417
{ .name = "debug", .key = 132,
371
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 },
372
432
{ .name = NULL }
373
433
};
374
434
375
error_t parse_opt(int key, char *arg, __attribute__((unused))
376
struct argp_state *state) {
377
switch(key) {
435
__attribute__((nonnull(3)))
436
error_t parse_opt(int key, char *arg, struct argp_state *state){
437
errno = 0;
438
switch(key){
439
char *tmp;
440
intmax_t tmp_id;
378
441
case 'g': /* --global-options */
379
if(arg != NULL){
380
char *p;
381
while((p = strsep(&arg, ",")) != NULL){
382
if(p[0] == '\0'){
383
continue;
384
}
385
if(not add_argument(getplugin(NULL), p)){
386
perror("add_argument");
387
return ARGP_ERR_UNKNOWN;
442
{
443
char *plugin_option;
444
while((plugin_option = strsep(&arg, ",")) != NULL){
445
if(not add_argument(getplugin(NULL), plugin_option)){
446
break;
388
447
}
389
448
}
449
errno = 0;
390
450
}
391
451
break;
392
452
case 'G': /* --global-env */
393
if(arg == NULL){
394
break;
395
}
396
if(not add_environment(getplugin(NULL), arg, true)){
397
perror("add_environment");
453
if(add_environment(getplugin(NULL), arg, true)){
454
errno = 0;
398
455
}
399
456
break;
400
457
case 'o': /* --options-for */
401
if(arg != NULL){
402
char *p_name = strsep(&arg, ":");
403
if(p_name[0] == '\0' or arg == NULL){
404
break;
405
}
406
char *opt = strsep(&arg, ":");
407
if(opt[0] == '\0' or opt == NULL){
408
break;
409
}
410
char *p;
411
while((p = strsep(&opt, ",")) != NULL){
412
if(p[0] == '\0'){
413
continue;
414
}
415
if(not add_argument(getplugin(p_name), p)){
416
perror("add_argument");
417
return ARGP_ERR_UNKNOWN;
418
}
419
}
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;
476
}
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
/* In the GNU C library, uid_t is always unsigned int */
467
ret = sscanf(arg, "%u", &uid);
468
if(ret != 1){
469
fprintf(stderr, "Bad user ID number: \"%s\", using %u\n", arg,
470
uid);
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;
471
536
}
537
uid = (uid_t)tmp_id;
538
errno = 0;
472
539
break;
473
540
case 131: /* --groupid */
474
/* In the GNU C library, gid_t is always unsigned int */
475
ret = sscanf(arg, "%u", &gid);
476
if(ret != 1){
477
fprintf(stderr, "Bad group ID number: \"%s\", using %u\n",
478
arg, gid);
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;
479
547
}
548
gid = (gid_t)tmp_id;
549
errno = 0;
480
550
break;
481
551
case 132: /* --debug */
482
552
debug = true;
483
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;
484
575
/*
485
576
* When adding more options before this line, remember to also add a
486
577
* "case" to the "parse_opt_config_file" function below.
489
580
/* Cryptsetup always passes an argument, which is an empty
490
581
string if "none" was specified in /etc/crypttab. So if
491
582
argument was empty, we ignore it silently. */
492
if(arg[0] != '\0'){
493
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
583
if(arg[0] == '\0'){
584
break;
494
585
}
495
break;
496
case ARGP_KEY_END:
497
break;
498
586
default:
499
587
return ARGP_ERR_UNKNOWN;
500
588
}
501
return 0;
589
return errno; /* Set to 0 at start */
502
590
}
503
591
504
592
/* This option parser is the same as parse_opt() above, except it
505
593
ignores everything but the --config-file option. */
506
594
error_t parse_opt_config_file(int key, char *arg,
507
595
__attribute__((unused))
508
struct argp_state *state) {
509
switch(key) {
596
struct argp_state *state){
597
errno = 0;
598
switch(key){
510
599
case 'g': /* --global-options */
511
600
case 'G': /* --global-env */
512
601
case 'o': /* --options-for */
518
607
case 129: /* --config-file */
519
608
free(argfile);
520
609
argfile = strdup(arg);
521
if(argfile == NULL){
522
perror("strdup");
610
if(argfile != NULL){
611
errno = 0;
523
612
}
524
break;
613
break;
525
614
case 130: /* --userid */
526
615
case 131: /* --groupid */
527
616
case 132: /* --debug */
617
case 133: /* --plugin-helper-dir */
618
case '?': /* --help */
619
case -3: /* --usage */
620
case 'V': /* --version */
528
621
case ARGP_KEY_ARG:
529
case ARGP_KEY_END:
530
622
break;
531
623
default:
532
624
return ARGP_ERR_UNKNOWN;
533
625
}
534
return 0;
626
return errno;
535
627
}
536
628
537
629
struct argp argp = { .options = options,
541
633
542
634
/* Parse using parse_opt_config_file() in order to get the custom
543
635
config file location, if any. */
544
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
545
if(ret == ARGP_ERR_UNKNOWN){
546
fprintf(stderr, "Unknown error while parsing arguments\n");
547
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;
548
650
goto fallback;
549
651
}
550
652
556
658
conffp = fopen(AFILE, "r");
557
659
} else {
558
660
conffp = fopen(argfile, "r");
559
}
661
}
560
662
if(conffp != NULL){
561
663
char *org_line = NULL;
562
664
char *p, *arg, *new_arg, *line;
563
665
size_t size = 0;
564
666
const char whitespace_delims[] = " \r\t\f\v\n";
565
667
const char comment_delim[] = "#";
566
668
567
669
custom_argc = 1;
568
670
custom_argv = malloc(sizeof(char*) * 2);
569
671
if(custom_argv == NULL){
570
perror("malloc");
571
exitstatus = EXIT_FAILURE;
672
error(0, errno, "malloc");
673
exitstatus = EX_OSERR;
572
674
goto fallback;
573
675
}
574
676
custom_argv[0] = argv[0];
575
677
custom_argv[1] = NULL;
576
678
577
679
/* for each line in the config file, strip whitespace and ignore
578
680
commented text */
579
681
while(true){
581
683
if(sret == -1){
582
684
break;
583
685
}
584
686
585
687
line = org_line;
586
688
arg = strsep(&line, comment_delim);
587
689
while((p = strsep(&arg, whitespace_delims)) != NULL){
590
692
}
591
693
new_arg = strdup(p);
592
694
if(new_arg == NULL){
593
perror("strdup");
594
exitstatus = EXIT_FAILURE;
695
error(0, errno, "strdup");
696
exitstatus = EX_OSERR;
595
697
free(org_line);
596
698
goto fallback;
597
699
}
598
700
599
701
custom_argc += 1;
600
custom_argv = realloc(custom_argv, sizeof(char *)
601
* ((unsigned int) custom_argc + 1));
602
if(custom_argv == NULL){
603
perror("realloc");
604
exitstatus = EXIT_FAILURE;
605
free(org_line);
606
goto fallback;
702
{
703
char **new_argv = realloc(custom_argv, sizeof(char *)
704
* ((unsigned int)
705
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
}
607
715
}
608
716
custom_argv[custom_argc-1] = new_arg;
609
custom_argv[custom_argc] = NULL;
717
custom_argv[custom_argc] = NULL;
610
718
}
611
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
}
612
728
free(org_line);
613
729
} else {
614
730
/* Check for harmful errors and go to fallback. Other errors might
615
731
not affect opening plugins */
616
732
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
617
perror("fopen");
618
exitstatus = EXIT_FAILURE;
733
error(0, errno, "fopen");
734
exitstatus = EX_OSERR;
619
735
goto fallback;
620
736
}
621
737
}
622
/* If there was any arguments from configuration file,
623
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 */
624
740
if(custom_argv != NULL){
625
ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
626
0, NULL);
627
if(ret == ARGP_ERR_UNKNOWN){
628
fprintf(stderr, "Unknown error while parsing arguments\n");
629
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;
630
755
goto fallback;
631
756
}
632
757
}
633
758
634
759
/* Parse actual command line arguments, to let them override the
635
760
config file */
636
ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
637
if(ret == ARGP_ERR_UNKNOWN){
638
fprintf(stderr, "Unknown error while parsing arguments\n");
639
exitstatus = EXIT_FAILURE;
640
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
}
641
794
}
642
795
643
796
if(debug){
647
800
for(char **a = p->argv; *a != NULL; a++){
648
801
fprintf(stderr, "\tArg: %s\n", *a);
649
802
}
650
fprintf(stderr, "...and %u environment variables\n", p->envc);
803
fprintf(stderr, "...and %d environment variables\n", p->envc);
651
804
for(char **a = p->environ; *a != NULL; a++){
652
805
fprintf(stderr, "\t%s\n", *a);
653
806
}
654
807
}
655
808
}
656
809
657
/* Strip permissions down to nobody */
810
if(getuid() == 0){
811
/* Work around Debian bug #633582:
812
<http://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);
836
if(ret == -1){
837
error(0, errno, "setgid");
838
}
658
839
ret = setuid(uid);
659
840
if(ret == -1){
660
perror("setuid");
661
}
662
setgid(gid);
663
if(ret == -1){
664
perror("setgid");
665
}
666
667
if(plugindir == NULL){
668
dir = opendir(PDIR);
669
} else {
670
dir = opendir(plugindir);
671
}
672
673
if(dir == NULL){
674
perror("Could not open plugin dir");
675
exitstatus = EXIT_FAILURE;
676
goto fallback;
677
}
678
679
/* 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 */
680
845
{
681
int dir_fd = dirfd(dir);
682
if(dir_fd >= 0){
683
ret = set_cloexec_flag(dir_fd);
684
if(ret < 0){
685
perror("set_cloexec_flag");
686
exitstatus = EXIT_FAILURE;
687
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;
688
890
}
689
891
}
892
return 1;
893
}
894
895
#ifdef __GLIBC__
896
#if __GLIBC_PREREQ(2, 15)
897
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
898
alphasort);
899
#else /* not __GLIBC_PREREQ(2, 15) */
900
int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
901
&direntries, good_name, alphasort);
902
#endif /* not __GLIBC_PREREQ(2, 15) */
903
#else /* not __GLIBC__ */
904
int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
905
&direntries, good_name, alphasort);
906
#endif /* not __GLIBC__ */
907
if(numplugins == -1){
908
error(0, errno, "Could not scan plugin dir");
909
direntries = NULL;
910
exitstatus = EX_OSERR;
911
goto fallback;
690
912
}
691
913
692
914
FD_ZERO(&rfds_all);
693
915
694
916
/* Read and execute any executable in the plugin directory*/
695
while(true){
696
dirst = readdir(dir);
697
698
/* All directory entries have been processed */
699
if(dirst == NULL){
700
if(errno == EBADF){
701
perror("readdir");
702
exitstatus = EXIT_FAILURE;
703
goto fallback;
704
}
705
break;
706
}
707
708
d_name_len = strlen(dirst->d_name);
709
710
/* Ignore dotfiles, backup files and other junk */
711
{
712
bool bad_name = false;
713
714
const char const *bad_prefixes[] = { ".", "#", NULL };
715
716
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
717
".dpkg-old",
718
".dpkg-bak",
719
".dpkg-divert", NULL };
720
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
721
size_t pre_len = strlen(*pre);
722
if((d_name_len >= pre_len)
723
and strncmp((dirst->d_name), *pre, pre_len) == 0){
724
if(debug){
725
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
726
" with bad prefix %s\n", dirst->d_name, *pre);
727
}
728
bad_name = true;
729
break;
730
}
731
}
732
if(bad_name){
733
continue;
734
}
735
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
736
size_t suf_len = strlen(*suf);
737
if((d_name_len >= suf_len)
738
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
739
== 0)){
740
if(debug){
741
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
742
" with bad suffix %s\n", dirst->d_name, *suf);
743
}
744
bad_name = true;
745
break;
746
}
747
}
748
749
if(bad_name){
750
continue;
751
}
752
}
753
754
char *filename;
755
if(plugindir == NULL){
756
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
757
} else {
758
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
759
}
760
if(ret < 0){
761
perror("asprintf");
917
for(int i = 0; i < numplugins; i++){
918
919
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
920
if(plugin_fd == -1){
921
error(0, errno, "Could not open plugin");
922
free(direntries[i]);
762
923
continue;
763
924
}
764
765
ret = stat(filename, &st);
925
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
766
926
if(ret == -1){
767
perror("stat");
768
free(filename);
927
error(0, errno, "stat");
928
close(plugin_fd);
929
free(direntries[i]);
769
930
continue;
770
931
}
771
932
772
933
/* Ignore non-executable files */
773
if(not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
934
if(not S_ISREG(st.st_mode)
935
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
936
X_OK, 0)) != 0)){
774
937
if(debug){
775
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
776
" with bad type or mode\n", filename);
938
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
939
" with bad type or mode\n",
940
plugindir != NULL ? plugindir : PDIR,
941
direntries[i]->d_name);
777
942
}
778
free(filename);
943
close(plugin_fd);
944
free(direntries[i]);
779
945
continue;
780
946
}
781
947
782
plugin *p = getplugin(dirst->d_name);
948
plugin *p = getplugin(direntries[i]->d_name);
783
949
if(p == NULL){
784
perror("getplugin");
785
free(filename);
950
error(0, errno, "getplugin");
951
close(plugin_fd);
952
free(direntries[i]);
786
953
continue;
787
954
}
788
955
if(p->disabled){
789
956
if(debug){
790
957
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
791
dirst->d_name);
958
direntries[i]->d_name);
792
959
}
793
free(filename);
960
close(plugin_fd);
961
free(direntries[i]);
794
962
continue;
795
963
}
796
964
{
799
967
if(g != NULL){
800
968
for(char **a = g->argv + 1; *a != NULL; a++){
801
969
if(not add_argument(p, *a)){
802
perror("add_argument");
970
error(0, errno, "add_argument");
803
971
}
804
972
}
805
973
/* Add global environment variables */
806
974
for(char **e = g->environ; *e != NULL; e++){
807
975
if(not add_environment(p, *e, false)){
808
perror("add_environment");
976
error(0, errno, "add_environment");
809
977
}
810
978
}
811
979
}
812
980
}
813
/* If this plugin has any environment variables, we will call
814
using execve and need to duplicate the environment from this
815
process, too. */
981
/* If this plugin has any environment variables, we need to
982
duplicate the environment from this process, too. */
816
983
if(p->environ[0] != NULL){
817
984
for(char **e = environ; *e != NULL; e++){
818
985
if(not add_environment(p, *e, false)){
819
perror("add_environment");
986
error(0, errno, "add_environment");
820
987
}
821
988
}
822
989
}
823
990
824
991
int pipefd[2];
825
ret = pipe(pipefd);
992
#ifndef O_CLOEXEC
993
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
994
#else /* O_CLOEXEC */
995
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
996
#endif /* O_CLOEXEC */
826
997
if(ret == -1){
827
perror("pipe");
828
exitstatus = EXIT_FAILURE;
829
goto fallback;
830
}
998
error(0, errno, "pipe");
999
exitstatus = EX_OSERR;
1000
free(direntries[i]);
1001
goto fallback;
1002
}
1003
if(pipefd[0] >= FD_SETSIZE){
1004
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1005
FD_SETSIZE);
1006
close(pipefd[0]);
1007
close(pipefd[1]);
1008
exitstatus = EX_OSERR;
1009
free(direntries[i]);
1010
goto fallback;
1011
}
1012
#ifndef O_CLOEXEC
831
1013
/* Ask OS to automatic close the pipe on exec */
832
1014
ret = set_cloexec_flag(pipefd[0]);
833
1015
if(ret < 0){
834
perror("set_cloexec_flag");
835
exitstatus = EXIT_FAILURE;
1016
error(0, errno, "set_cloexec_flag");
1017
close(pipefd[0]);
1018
close(pipefd[1]);
1019
exitstatus = EX_OSERR;
1020
free(direntries[i]);
836
1021
goto fallback;
837
1022
}
838
1023
ret = set_cloexec_flag(pipefd[1]);
839
1024
if(ret < 0){
840
perror("set_cloexec_flag");
841
exitstatus = EXIT_FAILURE;
1025
error(0, errno, "set_cloexec_flag");
1026
close(pipefd[0]);
1027
close(pipefd[1]);
1028
exitstatus = EX_OSERR;
1029
free(direntries[i]);
842
1030
goto fallback;
843
1031
}
1032
#endif /* not O_CLOEXEC */
844
1033
/* Block SIGCHLD until process is safely in process list */
845
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1034
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1035
&sigchld_action.sa_mask,
1036
NULL));
846
1037
if(ret < 0){
847
perror("sigprocmask");
848
exitstatus = EXIT_FAILURE;
1038
error(0, errno, "sigprocmask");
1039
exitstatus = EX_OSERR;
1040
free(direntries[i]);
849
1041
goto fallback;
850
1042
}
851
1043
/* Starting a new process to be watched */
852
pid_t pid = fork();
1044
pid_t pid;
1045
do {
1046
pid = fork();
1047
} while(pid == -1 and errno == EINTR);
853
1048
if(pid == -1){
854
perror("fork");
855
exitstatus = EXIT_FAILURE;
1049
error(0, errno, "fork");
1050
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1051
&sigchld_action.sa_mask, NULL));
1052
close(pipefd[0]);
1053
close(pipefd[1]);
1054
exitstatus = EX_OSERR;
1055
free(direntries[i]);
856
1056
goto fallback;
857
1057
}
858
1058
if(pid == 0){
859
1059
/* this is the child process */
860
1060
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
861
1061
if(ret < 0){
862
perror("sigaction");
863
_exit(EXIT_FAILURE);
1062
error(0, errno, "sigaction");
1063
_exit(EX_OSERR);
864
1064
}
865
1065
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
866
1066
if(ret < 0){
867
perror("sigprocmask");
868
_exit(EXIT_FAILURE);
1067
error(0, errno, "sigprocmask");
1068
_exit(EX_OSERR);
869
1069
}
870
1070
871
1071
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
872
1072
if(ret == -1){
873
perror("dup2");
874
_exit(EXIT_FAILURE);
1073
error(0, errno, "dup2");
1074
_exit(EX_OSERR);
875
1075
}
876
1076
877
if(dirfd(dir) < 0){
878
/* If dir has no file descriptor, we could not set FD_CLOEXEC
879
above and must now close it manually here. */
880
closedir(dir);
881
}
882
if(p->environ[0] == NULL){
883
if(execv(filename, p->argv) < 0){
884
perror("execv");
885
_exit(EXIT_FAILURE);
886
}
887
} else {
888
if(execve(filename, p->argv, p->environ) < 0){
889
perror("execve");
890
_exit(EXIT_FAILURE);
891
}
1077
if(fexecve(plugin_fd, p->argv,
1078
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1079
error(0, errno, "fexecve for %s/%s",
1080
plugindir != NULL ? plugindir : PDIR,
1081
direntries[i]->d_name);
1082
_exit(EX_OSERR);
892
1083
}
893
1084
/* no return */
894
1085
}
895
1086
/* Parent process */
896
1087
close(pipefd[1]); /* Close unused write end of pipe */
897
free(filename);
898
plugin *new_plugin = getplugin(dirst->d_name);
1088
close(plugin_fd);
1089
plugin *new_plugin = getplugin(direntries[i]->d_name);
899
1090
if(new_plugin == NULL){
900
perror("getplugin");
901
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1091
error(0, errno, "getplugin");
1092
ret = (int)(TEMP_FAILURE_RETRY
1093
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1094
NULL)));
902
1095
if(ret < 0){
903
perror("sigprocmask");
1096
error(0, errno, "sigprocmask");
904
1097
}
905
exitstatus = EXIT_FAILURE;
1098
exitstatus = EX_OSERR;
1099
free(direntries[i]);
906
1100
goto fallback;
907
1101
}
1102
free(direntries[i]);
908
1103
909
1104
new_plugin->pid = pid;
910
1105
new_plugin->fd = pipefd[0];
911
1106
912
1107
/* Unblock SIGCHLD so signal handler can be run if this process
913
1108
has already completed */
914
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1109
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1110
&sigchld_action.sa_mask,
1111
NULL));
915
1112
if(ret < 0){
916
perror("sigprocmask");
917
exitstatus = EXIT_FAILURE;
1113
error(0, errno, "sigprocmask");
1114
exitstatus = EX_OSERR;
918
1115
goto fallback;
919
1116
}
920
1117
921
FD_SET(new_plugin->fd, &rfds_all);
1118
#if defined (__GNUC__) and defined (__GLIBC__)
1119
#if not __GLIBC_PREREQ(2, 16)
1120
#pragma GCC diagnostic push
1121
#pragma GCC diagnostic ignored "-Wsign-conversion"
1122
#endif
1123
#endif
1124
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1125
-Wconversion in GNU libc
1126
before 2.16 */
1127
#if defined (__GNUC__) and defined (__GLIBC__)
1128
#if not __GLIBC_PREREQ(2, 16)
1129
#pragma GCC diagnostic pop
1130
#endif
1131
#endif
922
1132
923
1133
if(maxfd < new_plugin->fd){
924
1134
maxfd = new_plugin->fd;
925
1135
}
926
1136
}
927
1137
928
closedir(dir);
929
dir = NULL;
1138
free(direntries);
1139
direntries = NULL;
1140
close(dir_fd);
1141
dir_fd = -1;
1142
free_plugin(getplugin(NULL));
930
1143
931
1144
for(plugin *p = plugin_list; p != NULL; p = p->next){
932
1145
if(p->pid != 0){
943
1156
while(plugin_list){
944
1157
fd_set rfds = rfds_all;
945
1158
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
946
if(select_ret == -1){
947
perror("select");
948
exitstatus = EXIT_FAILURE;
1159
if(select_ret == -1 and errno != EINTR){
1160
error(0, errno, "select");
1161
exitstatus = EX_OSERR;
949
1162
goto fallback;
950
1163
}
951
1164
/* OK, now either a process completed, or something can be read
952
1165
from one of them */
953
1166
for(plugin *proc = plugin_list; proc != NULL;){
954
1167
/* Is this process completely done? */
955
if(proc->eof and proc->completed){
1168
if(proc->completed and proc->eof){
956
1169
/* Only accept the plugin output if it exited cleanly */
957
1170
if(not WIFEXITED(proc->status)
958
1171
or WEXITSTATUS(proc->status) != 0){
959
1172
/* Bad exit by plugin */
960
1173
961
1174
if(debug){
962
1175
if(WIFEXITED(proc->status)){
963
fprintf(stderr, "Plugin %u exited with status %d\n",
964
(unsigned int) (proc->pid),
1176
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1177
" status %d\n", proc->name,
1178
(intmax_t) (proc->pid),
965
1179
WEXITSTATUS(proc->status));
966
} else if(WIFSIGNALED(proc->status)) {
967
fprintf(stderr, "Plugin %u killed by signal %d\n",
968
(unsigned int) (proc->pid),
969
WTERMSIG(proc->status));
1180
} else if(WIFSIGNALED(proc->status)){
1181
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1182
" signal %d: %s\n", proc->name,
1183
(intmax_t) (proc->pid),
1184
WTERMSIG(proc->status),
1185
strsignal(WTERMSIG(proc->status)));
970
1186
} else if(WCOREDUMP(proc->status)){
971
fprintf(stderr, "Plugin %u dumped core\n",
972
(unsigned int) (proc->pid));
1187
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1188
" core\n", proc->name, (intmax_t) (proc->pid));
973
1189
}
974
1190
}
975
1191
976
1192
/* Remove the plugin */
977
FD_CLR(proc->fd, &rfds_all);
978
1193
#if defined (__GNUC__) and defined (__GLIBC__)
1194
#if not __GLIBC_PREREQ(2, 16)
1195
#pragma GCC diagnostic push
1196
#pragma GCC diagnostic ignored "-Wsign-conversion"
1197
#endif
1198
#endif
1199
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1200
-Wconversion in GNU libc
1201
before 2.16 */
1202
#if defined (__GNUC__) and defined (__GLIBC__)
1203
#if not __GLIBC_PREREQ(2, 16)
1204
#pragma GCC diagnostic pop
1205
#endif
1206
#endif
1207
979
1208
/* Block signal while modifying process_list */
980
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1209
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1210
(SIG_BLOCK,
1211
&sigchld_action.sa_mask,
1212
NULL));
981
1213
if(ret < 0){
982
perror("sigprocmask");
983
exitstatus = EXIT_FAILURE;
1214
error(0, errno, "sigprocmask");
1215
exitstatus = EX_OSERR;
984
1216
goto fallback;
985
1217
}
986
1218
989
1221
proc = next_plugin;
990
1222
991
1223
/* We are done modifying process list, so unblock signal */
992
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
993
NULL);
1224
ret = (int)(TEMP_FAILURE_RETRY
1225
(sigprocmask(SIG_UNBLOCK,
1226
&sigchld_action.sa_mask, NULL)));
994
1227
if(ret < 0){
995
perror("sigprocmask");
996
exitstatus = EXIT_FAILURE;
1228
error(0, errno, "sigprocmask");
1229
exitstatus = EX_OSERR;
997
1230
goto fallback;
998
1231
}
999
1232
1009
1242
bool bret = print_out_password(proc->buffer,
1010
1243
proc->buffer_length);
1011
1244
if(not bret){
1012
perror("print_out_password");
1013
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "print_out_password");
1246
exitstatus = EX_IOERR;
1014
1247
}
1015
1248
goto fallback;
1016
1249
}
1017
1250
1018
1251
/* This process has not completed. Does it have any output? */
1019
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1252
#if defined (__GNUC__) and defined (__GLIBC__)
1253
#if not __GLIBC_PREREQ(2, 16)
1254
#pragma GCC diagnostic push
1255
#pragma GCC diagnostic ignored "-Wsign-conversion"
1256
#endif
1257
#endif
1258
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1259
warning from
1260
-Wconversion
1261
in GNU libc
1262
before
1263
2.16 */
1264
#if defined (__GNUC__) and defined (__GLIBC__)
1265
#if not __GLIBC_PREREQ(2, 16)
1266
#pragma GCC diagnostic pop
1267
#endif
1268
#endif
1020
1269
/* This process had nothing to say at this time */
1021
1270
proc = proc->next;
1022
1271
continue;
1023
1272
}
1024
1273
/* Before reading, make the process' data buffer large enough */
1025
1274
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1026
proc->buffer = realloc(proc->buffer, proc->buffer_size
1027
+ (size_t) BUFFER_SIZE);
1028
if(proc->buffer == NULL){
1029
perror("malloc");
1030
exitstatus = EXIT_FAILURE;
1275
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1276
+ (size_t) BUFFER_SIZE);
1277
if(new_buffer == NULL){
1278
error(0, errno, "malloc");
1279
exitstatus = EX_OSERR;
1031
1280
goto fallback;
1032
1281
}
1282
proc->buffer = new_buffer;
1033
1283
proc->buffer_size += BUFFER_SIZE;
1034
1284
}
1035
1285
/* Read from the process */
1036
sret = read(proc->fd, proc->buffer + proc->buffer_length,
1037
BUFFER_SIZE);
1286
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1287
proc->buffer
1288
+ proc->buffer_length,
1289
BUFFER_SIZE));
1038
1290
if(sret < 0){
1039
1291
/* Read error from this process; ignore the error */
1040
1292
proc = proc->next;
1048
1300
}
1049
1301
}
1050
1302
}
1051
1052
1303
1304
1053
1305
fallback:
1054
1306
1055
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1307
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1308
and exitstatus != EX_OK)){
1056
1309
/* Fallback if all plugins failed, none are found or an error
1057
1310
occured */
1058
1311
bool bret;
1066
1319
}
1067
1320
bret = print_out_password(passwordbuffer, len);
1068
1321
if(not bret){
1069
perror("print_out_password");
1070
exitstatus = EXIT_FAILURE;
1322
error(0, errno, "print_out_password");
1323
exitstatus = EX_IOERR;
1071
1324
}
1072
1325
}
1073
1326
1074
1327
/* Restore old signal handler */
1075
1328
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1076
1329
if(ret == -1){
1077
perror("sigaction");
1078
exitstatus = EXIT_FAILURE;
1330
error(0, errno, "sigaction");
1331
exitstatus = EX_OSERR;
1079
1332
}
1080
1333
1081
1334
if(custom_argv != NULL){
1085
1338
free(custom_argv);
1086
1339
}
1087
1340
1088
if(dir != NULL){
1089
closedir(dir);
1341
free(direntries);
1342
1343
if(dir_fd != -1){
1344
close(dir_fd);
1090
1345
}
1091
1346
1092
1347
/* Kill the processes */
1096
1351
ret = kill(p->pid, SIGTERM);
1097
1352
if(ret == -1 and errno != ESRCH){
1098
1353
/* Set-uid proccesses might not get closed */
1099
perror("kill");
1354
error(0, errno, "kill");
1100
1355
}
1101
1356
}
1102
1357
}
1103
1358
1104
1359
/* Wait for any remaining child processes to terminate */
1105
do{
1360
do {
1106
1361
ret = wait(NULL);
1107
1362
} while(ret >= 0);
1108
1363
if(errno != ECHILD){
1109
perror("wait");
1364
error(0, errno, "wait");
1110
1365
}
1111
1366
1112
1367
free_plugin_list();
1113
1368
1114
1369
free(plugindir);
1370
free(pluginhelperdir);
1115
1371
free(argfile);
1116
1372
1117
1373
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0