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