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