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 removed:
- debian/mandos-client.config
- 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 */
102
for (plugin *p = plugin_list; p != NULL; p = p->next){
103
if ((p->name == name)
104
or (p->name and name and (strcmp(p->name, name) == 0))){
111
/* Check for existing plugin with that name */
112
for(plugin *p = plugin_list; p != NULL; p = p->next){
113
if((p->name == name)
114
or (p->name and name and (strcmp(p->name, name) == 0))){
105
115
return p;
106
116
}
107
117
}
108
118
/* Create a new plugin */
109
plugin *new_plugin = malloc(sizeof(plugin));
110
if (new_plugin == NULL){
119
plugin *new_plugin = NULL;
120
do {
121
new_plugin = malloc(sizeof(plugin));
122
} while(new_plugin == NULL and errno == EINTR);
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);
127
if (new_plugin->argv == NULL){
144
do {
145
new_plugin->argv = malloc(sizeof(char *) * 2);
146
} while(new_plugin->argv == NULL and errno == EINTR);
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;
358
ssize_t sret;
312
359
uid_t uid = 65534;
313
360
gid_t gid = 65534;
314
361
bool debug = false;
318
365
.sa_flags = SA_NOCLDSTOP };
319
366
char **custom_argv = NULL;
320
367
int custom_argc = 0;
368
int dir_fd = -1;
321
369
322
370
/* Establish a signal handler */
323
371
sigemptyset(&sigchld_action.sa_mask);
324
372
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
325
373
if(ret == -1){
326
perror("sigaddset");
327
exitstatus = EXIT_FAILURE;
374
error(0, errno, "sigaddset");
375
exitstatus = EX_OSERR;
328
376
goto fallback;
329
377
}
330
378
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
331
379
if(ret == -1){
332
perror("sigaction");
333
exitstatus = EXIT_FAILURE;
380
error(0, errno, "sigaction");
381
exitstatus = EX_OSERR;
334
382
goto fallback;
335
383
}
336
384
368
416
.doc = "Group ID the plugins will run as", .group = 3 },
369
417
{ .name = "debug", .key = 132,
370
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 },
371
432
{ .name = NULL }
372
433
};
373
434
374
error_t parse_opt (int key, char *arg, __attribute__((unused))
375
struct argp_state *state) {
376
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;
377
441
case 'g': /* --global-options */
378
if (arg != NULL){
379
char *p;
380
while((p = strsep(&arg, ",")) != NULL){
381
if(p[0] == '\0'){
382
continue;
383
}
384
if(not add_argument(getplugin(NULL), p)){
385
perror("add_argument");
386
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;
387
447
}
388
448
}
449
errno = 0;
389
450
}
390
451
break;
391
452
case 'G': /* --global-env */
392
if(arg == NULL){
393
break;
394
}
395
if(not add_environment(getplugin(NULL), arg, true)){
396
perror("add_environment");
453
if(add_environment(getplugin(NULL), arg, true)){
454
errno = 0;
397
455
}
398
456
break;
399
457
case 'o': /* --options-for */
400
if (arg != NULL){
401
char *p_name = strsep(&arg, ":");
402
if(p_name[0] == '\0' or arg == NULL){
403
break;
404
}
405
char *opt = strsep(&arg, ":");
406
if(opt[0] == '\0' or opt == NULL){
407
break;
408
}
409
char *p;
410
while((p = strsep(&opt, ",")) != NULL){
411
if(p[0] == '\0'){
412
continue;
413
}
414
if(not add_argument(getplugin(p_name), p)){
415
perror("add_argument");
416
return ARGP_ERR_UNKNOWN;
417
}
418
}
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;
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
uid = (uid_t)strtol(arg, NULL, 10);
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;
536
}
537
uid = (uid_t)tmp_id;
538
errno = 0;
466
539
break;
467
540
case 131: /* --groupid */
468
gid = (gid_t)strtol(arg, NULL, 10);
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;
547
}
548
gid = (gid_t)tmp_id;
549
errno = 0;
469
550
break;
470
551
case 132: /* --debug */
471
552
debug = true;
472
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;
575
/*
576
* When adding more options before this line, remember to also add a
577
* "case" to the "parse_opt_config_file" function below.
578
*/
473
579
case ARGP_KEY_ARG:
474
580
/* Cryptsetup always passes an argument, which is an empty
475
581
string if "none" was specified in /etc/crypttab. So if
476
582
argument was empty, we ignore it silently. */
477
if(arg[0] != '\0'){
478
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
583
if(arg[0] == '\0'){
584
break;
479
585
}
480
break;
481
case ARGP_KEY_END:
482
break;
483
586
default:
484
587
return ARGP_ERR_UNKNOWN;
485
588
}
486
return 0;
589
return errno; /* Set to 0 at start */
487
590
}
488
591
489
592
/* This option parser is the same as parse_opt() above, except it
490
593
ignores everything but the --config-file option. */
491
error_t parse_opt_config_file (int key, char *arg,
492
__attribute__((unused))
493
struct argp_state *state) {
494
switch (key) {
594
error_t parse_opt_config_file(int key, char *arg,
595
__attribute__((unused))
596
struct argp_state *state){
597
errno = 0;
598
switch(key){
495
599
case 'g': /* --global-options */
496
600
case 'G': /* --global-env */
497
601
case 'o': /* --options-for */
503
607
case 129: /* --config-file */
504
608
free(argfile);
505
609
argfile = strdup(arg);
506
if(argfile == NULL){
507
perror("strdup");
610
if(argfile != NULL){
611
errno = 0;
508
612
}
509
break;
613
break;
510
614
case 130: /* --userid */
511
615
case 131: /* --groupid */
512
616
case 132: /* --debug */
617
case 133: /* --plugin-helper-dir */
618
case '?': /* --help */
619
case -3: /* --usage */
620
case 'V': /* --version */
513
621
case ARGP_KEY_ARG:
514
case ARGP_KEY_END:
515
622
break;
516
623
default:
517
624
return ARGP_ERR_UNKNOWN;
518
625
}
519
return 0;
626
return errno;
520
627
}
521
628
522
629
struct argp argp = { .options = options,
524
631
.args_doc = "",
525
632
.doc = "Mandos plugin runner -- Run plugins" };
526
633
527
/* Parse using the parse_opt_config_file in order to get the custom
634
/* Parse using parse_opt_config_file() in order to get the custom
528
635
config file location, if any. */
529
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
530
if (ret == ARGP_ERR_UNKNOWN){
531
fprintf(stderr, "Unknown error while parsing arguments\n");
532
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;
533
650
goto fallback;
534
651
}
535
652
537
654
argp.parser = parse_opt;
538
655
539
656
/* Open the configfile if available */
540
if (argfile == NULL){
657
if(argfile == NULL){
541
658
conffp = fopen(AFILE, "r");
542
659
} else {
543
660
conffp = fopen(argfile, "r");
544
}
661
}
545
662
if(conffp != NULL){
546
663
char *org_line = NULL;
547
664
char *p, *arg, *new_arg, *line;
548
665
size_t size = 0;
549
ssize_t sret;
550
666
const char whitespace_delims[] = " \r\t\f\v\n";
551
667
const char comment_delim[] = "#";
552
668
553
669
custom_argc = 1;
554
670
custom_argv = malloc(sizeof(char*) * 2);
555
671
if(custom_argv == NULL){
556
perror("malloc");
557
exitstatus = EXIT_FAILURE;
672
error(0, errno, "malloc");
673
exitstatus = EX_OSERR;
558
674
goto fallback;
559
675
}
560
676
custom_argv[0] = argv[0];
561
677
custom_argv[1] = NULL;
562
678
563
679
/* for each line in the config file, strip whitespace and ignore
564
680
commented text */
565
681
while(true){
567
683
if(sret == -1){
568
684
break;
569
685
}
570
686
571
687
line = org_line;
572
688
arg = strsep(&line, comment_delim);
573
689
while((p = strsep(&arg, whitespace_delims)) != NULL){
576
692
}
577
693
new_arg = strdup(p);
578
694
if(new_arg == NULL){
579
perror("strdup");
580
exitstatus = EXIT_FAILURE;
695
error(0, errno, "strdup");
696
exitstatus = EX_OSERR;
581
697
free(org_line);
582
698
goto fallback;
583
699
}
584
700
585
701
custom_argc += 1;
586
custom_argv = realloc(custom_argv, sizeof(char *)
587
* ((unsigned int) custom_argc + 1));
588
if(custom_argv == NULL){
589
perror("realloc");
590
exitstatus = EXIT_FAILURE;
591
free(org_line);
592
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
}
593
715
}
594
716
custom_argv[custom_argc-1] = new_arg;
595
custom_argv[custom_argc] = NULL;
717
custom_argv[custom_argc] = NULL;
596
718
}
597
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
}
598
728
free(org_line);
599
729
} else {
600
730
/* Check for harmful errors and go to fallback. Other errors might
601
731
not affect opening plugins */
602
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
603
perror("fopen");
604
exitstatus = EXIT_FAILURE;
732
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
733
error(0, errno, "fopen");
734
exitstatus = EX_OSERR;
605
735
goto fallback;
606
736
}
607
737
}
608
/* If there was any arguments from configuration file,
609
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 */
610
740
if(custom_argv != NULL){
611
ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
612
0, NULL);
613
if (ret == ARGP_ERR_UNKNOWN){
614
fprintf(stderr, "Unknown error while parsing arguments\n");
615
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;
616
755
goto fallback;
617
756
}
618
757
}
619
758
620
759
/* Parse actual command line arguments, to let them override the
621
760
config file */
622
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
623
if (ret == ARGP_ERR_UNKNOWN){
624
fprintf(stderr, "Unknown error while parsing arguments\n");
625
exitstatus = EXIT_FAILURE;
626
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
}
627
794
}
628
795
629
796
if(debug){
633
800
for(char **a = p->argv; *a != NULL; a++){
634
801
fprintf(stderr, "\tArg: %s\n", *a);
635
802
}
636
fprintf(stderr, "...and %u environment variables\n", p->envc);
803
fprintf(stderr, "...and %d environment variables\n", p->envc);
637
804
for(char **a = p->environ; *a != NULL; a++){
638
805
fprintf(stderr, "\t%s\n", *a);
639
806
}
640
807
}
641
808
}
642
809
643
/* 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
}
644
839
ret = setuid(uid);
645
if (ret == -1){
646
perror("setuid");
647
}
648
setgid(gid);
649
if (ret == -1){
650
perror("setgid");
651
}
652
653
if (plugindir == NULL){
654
dir = opendir(PDIR);
655
} else {
656
dir = opendir(plugindir);
657
}
658
659
if(dir == NULL){
660
perror("Could not open plugin dir");
661
exitstatus = EXIT_FAILURE;
662
goto fallback;
663
}
664
665
/* Set the FD_CLOEXEC flag on the directory, if possible */
840
if(ret == -1){
841
error(0, errno, "setuid");
842
}
843
844
/* Open plugin directory with close_on_exec flag */
666
845
{
667
int dir_fd = dirfd(dir);
668
if(dir_fd >= 0){
669
ret = set_cloexec_flag(dir_fd);
670
if(ret < 0){
671
perror("set_cloexec_flag");
672
exitstatus = EXIT_FAILURE;
673
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;
674
890
}
675
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;
676
912
}
677
913
678
914
FD_ZERO(&rfds_all);
679
915
680
916
/* Read and execute any executable in the plugin directory*/
681
while(true){
682
dirst = readdir(dir);
683
684
/* All directory entries have been processed */
685
if(dirst == NULL){
686
if (errno == EBADF){
687
perror("readdir");
688
exitstatus = EXIT_FAILURE;
689
goto fallback;
690
}
691
break;
692
}
693
694
d_name_len = strlen(dirst->d_name);
695
696
/* Ignore dotfiles, backup files and other junk */
697
{
698
bool bad_name = false;
699
700
const char const *bad_prefixes[] = { ".", "#", NULL };
701
702
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
703
".dpkg-old",
704
".dpkg-bak",
705
".dpkg-divert", NULL };
706
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
707
size_t pre_len = strlen(*pre);
708
if((d_name_len >= pre_len)
709
and strncmp((dirst->d_name), *pre, pre_len) == 0){
710
if(debug){
711
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
712
" with bad prefix %s\n", dirst->d_name, *pre);
713
}
714
bad_name = true;
715
break;
716
}
717
}
718
if(bad_name){
719
continue;
720
}
721
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
722
size_t suf_len = strlen(*suf);
723
if((d_name_len >= suf_len)
724
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
725
== 0)){
726
if(debug){
727
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
728
" with bad suffix %s\n", dirst->d_name, *suf);
729
}
730
bad_name = true;
731
break;
732
}
733
}
734
735
if(bad_name){
736
continue;
737
}
738
}
739
740
char *filename;
741
if(plugindir == NULL){
742
ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
743
} else {
744
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
745
}
746
if(ret < 0){
747
perror("asprintf");
748
continue;
749
}
750
751
ret = stat(filename, &st);
752
if (ret == -1){
753
perror("stat");
754
free(filename);
755
continue;
756
}
757
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]);
923
continue;
924
}
925
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
926
if(ret == -1){
927
error(0, errno, "stat");
928
close(plugin_fd);
929
free(direntries[i]);
930
continue;
931
}
932
758
933
/* Ignore non-executable files */
759
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)){
760
937
if(debug){
761
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
762
" 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);
763
942
}
764
free(filename);
943
close(plugin_fd);
944
free(direntries[i]);
765
945
continue;
766
946
}
767
947
768
plugin *p = getplugin(dirst->d_name);
948
plugin *p = getplugin(direntries[i]->d_name);
769
949
if(p == NULL){
770
perror("getplugin");
771
free(filename);
950
error(0, errno, "getplugin");
951
close(plugin_fd);
952
free(direntries[i]);
772
953
continue;
773
954
}
774
955
if(p->disabled){
775
956
if(debug){
776
957
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
777
dirst->d_name);
958
direntries[i]->d_name);
778
959
}
779
free(filename);
960
close(plugin_fd);
961
free(direntries[i]);
780
962
continue;
781
963
}
782
964
{
785
967
if(g != NULL){
786
968
for(char **a = g->argv + 1; *a != NULL; a++){
787
969
if(not add_argument(p, *a)){
788
perror("add_argument");
970
error(0, errno, "add_argument");
789
971
}
790
972
}
791
973
/* Add global environment variables */
792
974
for(char **e = g->environ; *e != NULL; e++){
793
975
if(not add_environment(p, *e, false)){
794
perror("add_environment");
976
error(0, errno, "add_environment");
795
977
}
796
978
}
797
979
}
798
980
}
799
/* If this plugin has any environment variables, we will call
800
using execve and need to duplicate the environment from this
801
process, too. */
981
/* If this plugin has any environment variables, we need to
982
duplicate the environment from this process, too. */
802
983
if(p->environ[0] != NULL){
803
984
for(char **e = environ; *e != NULL; e++){
804
985
if(not add_environment(p, *e, false)){
805
perror("add_environment");
986
error(0, errno, "add_environment");
806
987
}
807
988
}
808
989
}
809
990
810
991
int pipefd[2];
811
ret = pipe(pipefd);
812
if (ret == -1){
813
perror("pipe");
814
exitstatus = EXIT_FAILURE;
815
goto fallback;
816
}
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 */
997
if(ret == -1){
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
817
1013
/* Ask OS to automatic close the pipe on exec */
818
1014
ret = set_cloexec_flag(pipefd[0]);
819
1015
if(ret < 0){
820
perror("set_cloexec_flag");
821
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]);
822
1021
goto fallback;
823
1022
}
824
1023
ret = set_cloexec_flag(pipefd[1]);
825
1024
if(ret < 0){
826
perror("set_cloexec_flag");
827
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]);
828
1030
goto fallback;
829
1031
}
1032
#endif /* not O_CLOEXEC */
830
1033
/* Block SIGCHLD until process is safely in process list */
831
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));
832
1037
if(ret < 0){
833
perror("sigprocmask");
834
exitstatus = EXIT_FAILURE;
1038
error(0, errno, "sigprocmask");
1039
exitstatus = EX_OSERR;
1040
free(direntries[i]);
835
1041
goto fallback;
836
1042
}
837
1043
/* Starting a new process to be watched */
838
pid_t pid = fork();
1044
pid_t pid;
1045
do {
1046
pid = fork();
1047
} while(pid == -1 and errno == EINTR);
839
1048
if(pid == -1){
840
perror("fork");
841
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]);
842
1056
goto fallback;
843
1057
}
844
1058
if(pid == 0){
845
1059
/* this is the child process */
846
1060
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
847
1061
if(ret < 0){
848
perror("sigaction");
849
_exit(EXIT_FAILURE);
1062
error(0, errno, "sigaction");
1063
_exit(EX_OSERR);
850
1064
}
851
1065
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
852
1066
if(ret < 0){
853
perror("sigprocmask");
854
_exit(EXIT_FAILURE);
1067
error(0, errno, "sigprocmask");
1068
_exit(EX_OSERR);
855
1069
}
856
1070
857
1071
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
858
1072
if(ret == -1){
859
perror("dup2");
860
_exit(EXIT_FAILURE);
1073
error(0, errno, "dup2");
1074
_exit(EX_OSERR);
861
1075
}
862
1076
863
if(dirfd(dir) < 0){
864
/* If dir has no file descriptor, we could not set FD_CLOEXEC
865
above and must now close it manually here. */
866
closedir(dir);
867
}
868
if(p->environ[0] == NULL){
869
if(execv(filename, p->argv) < 0){
870
perror("execv");
871
_exit(EXIT_FAILURE);
872
}
873
} else {
874
if(execve(filename, p->argv, p->environ) < 0){
875
perror("execve");
876
_exit(EXIT_FAILURE);
877
}
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);
878
1083
}
879
1084
/* no return */
880
1085
}
881
1086
/* Parent process */
882
1087
close(pipefd[1]); /* Close unused write end of pipe */
883
free(filename);
884
plugin *new_plugin = getplugin(dirst->d_name);
885
if (new_plugin == NULL){
886
perror("getplugin");
887
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1088
close(plugin_fd);
1089
plugin *new_plugin = getplugin(direntries[i]->d_name);
1090
if(new_plugin == NULL){
1091
error(0, errno, "getplugin");
1092
ret = (int)(TEMP_FAILURE_RETRY
1093
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1094
NULL)));
888
1095
if(ret < 0){
889
perror("sigprocmask");
1096
error(0, errno, "sigprocmask");
890
1097
}
891
exitstatus = EXIT_FAILURE;
1098
exitstatus = EX_OSERR;
1099
free(direntries[i]);
892
1100
goto fallback;
893
1101
}
1102
free(direntries[i]);
894
1103
895
1104
new_plugin->pid = pid;
896
1105
new_plugin->fd = pipefd[0];
897
1106
898
1107
/* Unblock SIGCHLD so signal handler can be run if this process
899
1108
has already completed */
900
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));
901
1112
if(ret < 0){
902
perror("sigprocmask");
903
exitstatus = EXIT_FAILURE;
1113
error(0, errno, "sigprocmask");
1114
exitstatus = EX_OSERR;
904
1115
goto fallback;
905
1116
}
906
1117
907
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
908
1132
909
if (maxfd < new_plugin->fd){
1133
if(maxfd < new_plugin->fd){
910
1134
maxfd = new_plugin->fd;
911
1135
}
912
1136
}
913
1137
914
closedir(dir);
915
dir = NULL;
1138
free(direntries);
1139
direntries = NULL;
1140
close(dir_fd);
1141
dir_fd = -1;
1142
free_plugin(getplugin(NULL));
916
1143
917
1144
for(plugin *p = plugin_list; p != NULL; p = p->next){
918
1145
if(p->pid != 0){
929
1156
while(plugin_list){
930
1157
fd_set rfds = rfds_all;
931
1158
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
932
if (select_ret == -1){
933
perror("select");
934
exitstatus = EXIT_FAILURE;
1159
if(select_ret == -1 and errno != EINTR){
1160
error(0, errno, "select");
1161
exitstatus = EX_OSERR;
935
1162
goto fallback;
936
1163
}
937
1164
/* OK, now either a process completed, or something can be read
938
1165
from one of them */
939
1166
for(plugin *proc = plugin_list; proc != NULL;){
940
1167
/* Is this process completely done? */
941
if(proc->eof and proc->completed){
1168
if(proc->completed and proc->eof){
942
1169
/* Only accept the plugin output if it exited cleanly */
943
1170
if(not WIFEXITED(proc->status)
944
1171
or WEXITSTATUS(proc->status) != 0){
945
1172
/* Bad exit by plugin */
946
1173
947
1174
if(debug){
948
1175
if(WIFEXITED(proc->status)){
949
fprintf(stderr, "Plugin %u exited with status %d\n",
950
(unsigned int) (proc->pid),
1176
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1177
" status %d\n", proc->name,
1178
(intmax_t) (proc->pid),
951
1179
WEXITSTATUS(proc->status));
952
} else if(WIFSIGNALED(proc->status)) {
953
fprintf(stderr, "Plugin %u killed by signal %d\n",
954
(unsigned int) (proc->pid),
955
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)));
956
1186
} else if(WCOREDUMP(proc->status)){
957
fprintf(stderr, "Plugin %d dumped core\n",
958
(unsigned int) (proc->pid));
1187
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1188
" core\n", proc->name, (intmax_t) (proc->pid));
959
1189
}
960
1190
}
961
1191
962
1192
/* Remove the plugin */
963
FD_CLR(proc->fd, &rfds_all);
964
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
965
1208
/* Block signal while modifying process_list */
966
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));
967
1213
if(ret < 0){
968
perror("sigprocmask");
969
exitstatus = EXIT_FAILURE;
1214
error(0, errno, "sigprocmask");
1215
exitstatus = EX_OSERR;
970
1216
goto fallback;
971
1217
}
972
1218
975
1221
proc = next_plugin;
976
1222
977
1223
/* We are done modifying process list, so unblock signal */
978
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
979
NULL);
1224
ret = (int)(TEMP_FAILURE_RETRY
1225
(sigprocmask(SIG_UNBLOCK,
1226
&sigchld_action.sa_mask, NULL)));
980
1227
if(ret < 0){
981
perror("sigprocmask");
982
exitstatus = EXIT_FAILURE;
1228
error(0, errno, "sigprocmask");
1229
exitstatus = EX_OSERR;
983
1230
goto fallback;
984
1231
}
985
1232
995
1242
bool bret = print_out_password(proc->buffer,
996
1243
proc->buffer_length);
997
1244
if(not bret){
998
perror("print_out_password");
999
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "print_out_password");
1246
exitstatus = EX_IOERR;
1000
1247
}
1001
1248
goto fallback;
1002
1249
}
1003
1250
1004
1251
/* This process has not completed. Does it have any output? */
1005
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
1006
1269
/* This process had nothing to say at this time */
1007
1270
proc = proc->next;
1008
1271
continue;
1009
1272
}
1010
1273
/* Before reading, make the process' data buffer large enough */
1011
1274
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1012
proc->buffer = realloc(proc->buffer, proc->buffer_size
1013
+ (size_t) BUFFER_SIZE);
1014
if (proc->buffer == NULL){
1015
perror("malloc");
1016
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;
1017
1280
goto fallback;
1018
1281
}
1282
proc->buffer = new_buffer;
1019
1283
proc->buffer_size += BUFFER_SIZE;
1020
1284
}
1021
1285
/* Read from the process */
1022
ret = read(proc->fd, proc->buffer + proc->buffer_length,
1023
BUFFER_SIZE);
1024
if(ret < 0){
1286
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1287
proc->buffer
1288
+ proc->buffer_length,
1289
BUFFER_SIZE));
1290
if(sret < 0){
1025
1291
/* Read error from this process; ignore the error */
1026
1292
proc = proc->next;
1027
1293
continue;
1028
1294
}
1029
if(ret == 0){
1295
if(sret == 0){
1030
1296
/* got EOF */
1031
1297
proc->eof = true;
1032
1298
} else {
1033
proc->buffer_length += (size_t) ret;
1299
proc->buffer_length += (size_t) sret;
1034
1300
}
1035
1301
}
1036
1302
}
1037
1038
1303
1304
1039
1305
fallback:
1040
1306
1041
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1307
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1308
and exitstatus != EX_OK)){
1042
1309
/* Fallback if all plugins failed, none are found or an error
1043
1310
occured */
1044
1311
bool bret;
1052
1319
}
1053
1320
bret = print_out_password(passwordbuffer, len);
1054
1321
if(not bret){
1055
perror("print_out_password");
1056
exitstatus = EXIT_FAILURE;
1322
error(0, errno, "print_out_password");
1323
exitstatus = EX_IOERR;
1057
1324
}
1058
1325
}
1059
1326
1060
1327
/* Restore old signal handler */
1061
1328
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1062
1329
if(ret == -1){
1063
perror("sigaction");
1064
exitstatus = EXIT_FAILURE;
1330
error(0, errno, "sigaction");
1331
exitstatus = EX_OSERR;
1065
1332
}
1066
1333
1067
1334
if(custom_argv != NULL){
1071
1338
free(custom_argv);
1072
1339
}
1073
1340
1074
if(dir != NULL){
1075
closedir(dir);
1341
free(direntries);
1342
1343
if(dir_fd != -1){
1344
close(dir_fd);
1076
1345
}
1077
1346
1078
1347
/* Kill the processes */
1082
1351
ret = kill(p->pid, SIGTERM);
1083
1352
if(ret == -1 and errno != ESRCH){
1084
1353
/* Set-uid proccesses might not get closed */
1085
perror("kill");
1354
error(0, errno, "kill");
1086
1355
}
1087
1356
}
1088
1357
}
1089
1358
1090
1359
/* Wait for any remaining child processes to terminate */
1091
do{
1360
do {
1092
1361
ret = wait(NULL);
1093
1362
} while(ret >= 0);
1094
1363
if(errno != ECHILD){
1095
perror("wait");
1364
error(0, errno, "wait");
1096
1365
}
1097
1366
1098
1367
free_plugin_list();
1099
1368
1100
1369
free(plugindir);
1370
free(pluginhelperdir);
1101
1371
free(argfile);
1102
1372
1103
1373
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0