To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugin-runner.c
- browse files at revision 237.7.761
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.761
- Committer: teddy at recompile
- Date: 2020-04-05 21:30:59 UTC
- mto: This revision was merged to the branch mainline in revision 398.
- 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 */
182
static bool add_environment(plugin *p, const char *def){
227
__attribute__((nonnull(2), warn_unused_result))
228
static bool add_environment(plugin *p, const char *def, bool replace){
183
229
if(p == NULL){
184
230
return false;
185
231
}
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){
191
/* Refuse to add an existing variable */
235
for(char **envdef = p->environ; *envdef != NULL; envdef++){
236
if(strncmp(*envdef, def, namelen + 1) == 0){
237
/* It already exists */
238
if(replace){
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){
244
return false;
245
}
246
*envdef = new_envdef;
247
strcpy(*envdef, def);
248
}
192
249
return true;
193
250
}
194
251
}
195
252
return add_to_char_array(def, &(p->environ), &(p->envc));
196
253
}
197
254
255
#ifndef O_CLOEXEC
198
256
/*
199
257
* Based on the example in the GNU LibC manual chapter 13.13 "File
200
258
* Descriptor Flags".
201
* *Note File Descriptor Flags:(libc)Descriptor Flags.
259
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
202
260
*/
203
static int set_cloexec_flag(int fd)
204
{
205
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));
206
264
/* If reading the flags failed, return error indication now. */
207
265
if(ret < 0){
208
266
return ret;
209
267
}
210
268
/* Store modified flag word in the descriptor. */
211
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
269
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
270
ret | FD_CLOEXEC));
212
271
}
272
#endif /* not O_CLOEXEC */
213
273
214
274
215
275
/* Mark processes as completed when they exit, and save their exit
216
276
status. */
217
void handle_sigchld(__attribute__((unused)) int sig){
277
static void handle_sigchld(__attribute__((unused)) int sig){
278
int old_errno = errno;
218
279
while(true){
219
280
plugin *proc = plugin_list;
220
281
int status;
224
285
break;
225
286
}
226
287
if(pid == -1){
227
if (errno != ECHILD){
228
perror("waitpid");
288
if(errno == ECHILD){
289
/* No child processes */
290
break;
229
291
}
230
/* No child processes */
231
break;
292
error(0, errno, "waitpid");
232
293
}
233
294
234
295
/* A child exited, find it in process_list */
235
296
while(proc != NULL and proc->pid != pid){
236
297
proc = proc->next;
240
301
continue;
241
302
}
242
303
proc->status = status;
243
proc->completed = true;
304
proc->completed = 1;
244
305
}
306
errno = old_errno;
245
307
}
246
308
247
309
/* Prints out a password to stdout */
248
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){
249
312
ssize_t ret;
250
if(length>0 and buffer[length-1] == '\n'){
251
length--;
252
}
253
313
for(size_t written = 0; written < length; written += (size_t)ret){
254
314
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
255
315
length - written));
261
321
}
262
322
263
323
/* Removes and free a plugin from the plugin list */
324
__attribute__((nonnull))
264
325
static void free_plugin(plugin *plugin_node){
265
326
266
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
327
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
267
328
free(*arg);
268
329
}
330
free(plugin_node->name);
269
331
free(plugin_node->argv);
270
332
for(char **env = plugin_node->environ; *env != NULL; env++){
271
333
free(*env);
272
334
}
273
335
free(plugin_node->environ);
274
336
free(plugin_node->buffer);
275
337
276
338
/* Removes the plugin from the singly-linked list */
277
339
if(plugin_node == plugin_list){
278
340
/* First one - simple */
298
360
299
361
int main(int argc, char *argv[]){
300
362
char *plugindir = NULL;
363
char *pluginhelperdir = NULL;
301
364
char *argfile = NULL;
302
365
FILE *conffp;
303
size_t d_name_len;
304
DIR *dir = NULL;
305
struct dirent *dirst;
366
struct dirent **direntries = NULL;
306
367
struct stat st;
307
368
fd_set rfds_all;
308
369
int ret, maxfd = 0;
370
ssize_t sret;
309
371
uid_t uid = 65534;
310
372
gid_t gid = 65534;
311
373
bool debug = false;
315
377
.sa_flags = SA_NOCLDSTOP };
316
378
char **custom_argv = NULL;
317
379
int custom_argc = 0;
380
int dir_fd = -1;
318
381
319
382
/* Establish a signal handler */
320
383
sigemptyset(&sigchld_action.sa_mask);
321
384
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
322
385
if(ret == -1){
323
perror("sigaddset");
324
exitstatus = EXIT_FAILURE;
386
error(0, errno, "sigaddset");
387
exitstatus = EX_OSERR;
325
388
goto fallback;
326
389
}
327
390
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
328
391
if(ret == -1){
329
perror("sigaction");
330
exitstatus = EXIT_FAILURE;
392
error(0, errno, "sigaction");
393
exitstatus = EX_OSERR;
331
394
goto fallback;
332
395
}
333
396
336
399
{ .name = "global-options", .key = 'g',
337
400
.arg = "OPTION[,OPTION[,...]]",
338
401
.doc = "Options passed to all plugins" },
339
{ .name = "global-env", .key = 'e',
402
{ .name = "global-env", .key = 'G',
340
403
.arg = "VAR=value",
341
404
.doc = "Environment variable passed to all plugins" },
342
405
{ .name = "options-for", .key = 'o',
343
406
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
344
407
.doc = "Options passed only to specified plugin" },
345
{ .name = "env-for", .key = 'f',
408
{ .name = "env-for", .key = 'E',
346
409
.arg = "PLUGIN:ENV=value",
347
410
.doc = "Environment variable passed to specified plugin" },
348
411
{ .name = "disable", .key = 'd',
349
412
.arg = "PLUGIN",
350
413
.doc = "Disable a specific plugin", .group = 1 },
414
{ .name = "enable", .key = 'e',
415
.arg = "PLUGIN",
416
.doc = "Enable a specific plugin", .group = 1 },
351
417
{ .name = "plugin-dir", .key = 128,
352
418
.arg = "DIRECTORY",
353
419
.doc = "Specify a different plugin directory", .group = 2 },
362
428
.doc = "Group ID the plugins will run as", .group = 3 },
363
429
{ .name = "debug", .key = 132,
364
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 },
365
444
{ .name = NULL }
366
445
};
367
446
368
error_t parse_opt (int key, char *arg, __attribute__((unused))
369
struct argp_state *state) {
370
/* Get the INPUT argument from `argp_parse', which we know is a
371
pointer to our plugin list pointer. */
372
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;
373
453
case 'g': /* --global-options */
374
if (arg != NULL){
375
char *p;
376
while((p = strsep(&arg, ",")) != NULL){
377
if(p[0] == '\0'){
378
continue;
379
}
380
if(not add_argument(getplugin(NULL), p)){
381
perror("add_argument");
382
return ARGP_ERR_UNKNOWN;
383
}
384
}
385
}
386
break;
387
case 'e': /* --global-env */
388
if(arg == NULL){
389
break;
390
}
391
454
{
392
char *envdef = strdup(arg);
393
if(envdef == NULL){
394
break;
395
}
396
if(not add_environment(getplugin(NULL), envdef)){
397
perror("add_environment");
398
}
455
char *plugin_option;
456
while((plugin_option = strsep(&arg, ",")) != NULL){
457
if(not add_argument(getplugin(NULL), plugin_option)){
458
break;
459
}
460
}
461
errno = 0;
462
}
463
break;
464
case 'G': /* --global-env */
465
if(add_environment(getplugin(NULL), arg, true)){
466
errno = 0;
399
467
}
400
468
break;
401
469
case 'o': /* --options-for */
402
if (arg != NULL){
403
char *p_name = strsep(&arg, ":");
404
if(p_name[0] == '\0'){
405
break;
406
}
407
char *opt = strsep(&arg, ":");
408
if(opt[0] == '\0'){
409
break;
410
}
411
if(opt != NULL){
412
char *p;
413
while((p = strsep(&opt, ",")) != NULL){
414
if(p[0] == '\0'){
415
continue;
416
}
417
if(not add_argument(getplugin(p_name), p)){
418
perror("add_argument");
419
return ARGP_ERR_UNKNOWN;
420
}
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;
421
488
}
422
489
}
490
errno = 0;
423
491
}
424
492
break;
425
case 'f': /* --env-for */
426
if(arg == NULL){
427
break;
428
}
493
case 'E': /* --env-for */
429
494
{
430
495
char *envdef = strchr(arg, ':');
431
496
if(envdef == NULL){
432
break;
433
}
434
char *p_name = strndup(arg, (size_t) (envdef-arg));
435
if(p_name == NULL){
436
break;
437
}
497
argp_error(state, "No colon in \"%s\"", arg);
498
errno = EINVAL;
499
break;
500
}
501
*envdef = '\0';
438
502
envdef++;
439
if(not add_environment(getplugin(p_name), envdef)){
440
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;
441
510
}
442
511
}
443
512
break;
444
513
case 'd': /* --disable */
445
if (arg != NULL){
446
plugin *p = getplugin(arg);
447
if(p == NULL){
448
return ARGP_ERR_UNKNOWN;
449
}
450
p->disabled = true;
514
{
515
plugin *p = getplugin(arg);
516
if(p != NULL){
517
p->disabled = true;
518
errno = 0;
519
}
520
}
521
break;
522
case 'e': /* --enable */
523
{
524
plugin *p = getplugin(arg);
525
if(p != NULL){
526
p->disabled = false;
527
errno = 0;
528
}
451
529
}
452
530
break;
453
531
case 128: /* --plugin-dir */
532
free(plugindir);
454
533
plugindir = strdup(arg);
455
if(plugindir == NULL){
456
perror("strdup");
457
}
458
break;
459
case 129: /* --config-file */
534
if(plugindir != NULL){
535
errno = 0;
536
}
537
break;
538
case 129: /* --config-file */
539
/* This is already done by parse_opt_config_file() */
540
break;
541
case 130: /* --userid */
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;
551
break;
552
case 131: /* --groupid */
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;
562
break;
563
case 132: /* --debug */
564
debug = true;
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
*/
593
case ARGP_KEY_ARG:
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
605
default:
606
return ARGP_ERR_UNKNOWN;
607
}
608
return errno; /* Set to 0 at start */
609
}
610
611
/* This option parser is the same as parse_opt() above, except it
612
ignores everything but the --config-file option. */
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){
618
case 'g': /* --global-options */
619
case 'G': /* --global-env */
620
case 'o': /* --options-for */
621
case 'E': /* --env-for */
622
case 'd': /* --disable */
623
case 'e': /* --enable */
624
case 128: /* --plugin-dir */
625
break;
626
case 129: /* --config-file */
627
free(argfile);
460
628
argfile = strdup(arg);
461
if(argfile == NULL){
462
perror("strdup");
629
if(argfile != NULL){
630
errno = 0;
463
631
}
464
break;
632
break;
465
633
case 130: /* --userid */
466
uid = (uid_t)strtol(arg, NULL, 10);
467
break;
468
634
case 131: /* --groupid */
469
gid = (gid_t)strtol(arg, NULL, 10);
470
break;
471
635
case 132: /* --debug */
472
debug = true;
473
break;
636
case 133: /* --plugin-helper-dir */
637
case '?': /* --help */
638
case -3: /* --usage */
639
case 'V': /* --version */
474
640
case ARGP_KEY_ARG:
475
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
476
break;
477
case ARGP_KEY_END:
478
641
break;
479
642
default:
480
643
return ARGP_ERR_UNKNOWN;
481
644
}
482
return 0;
645
return errno;
483
646
}
484
647
485
struct argp argp = { .options = options, .parser = parse_opt,
486
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
648
struct argp argp = { .options = options,
649
.parser = parse_opt_config_file,
650
.args_doc = "",
487
651
.doc = "Mandos plugin runner -- Run plugins" };
488
652
489
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
490
if (ret == ARGP_ERR_UNKNOWN){
491
fprintf(stderr, "Unknown error while parsing arguments\n");
492
exitstatus = EXIT_FAILURE;
653
/* Parse using parse_opt_config_file() in order to get the custom
654
config file location, if any. */
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;
493
669
goto fallback;
494
670
}
495
496
/* Opens the configfile if aviable */
497
if (argfile == NULL){
671
672
/* Reset to the normal argument parser */
673
argp.parser = parse_opt;
674
675
/* Open the configfile if available */
676
if(argfile == NULL){
498
677
conffp = fopen(AFILE, "r");
499
678
} else {
500
679
conffp = fopen(argfile, "r");
501
}
680
}
502
681
if(conffp != NULL){
503
682
char *org_line = NULL;
504
683
char *p, *arg, *new_arg, *line;
505
684
size_t size = 0;
506
ssize_t sret;
507
685
const char whitespace_delims[] = " \r\t\f\v\n";
508
686
const char comment_delim[] = "#";
509
687
510
688
custom_argc = 1;
511
689
custom_argv = malloc(sizeof(char*) * 2);
512
690
if(custom_argv == NULL){
513
perror("malloc");
514
exitstatus = EXIT_FAILURE;
691
error(0, errno, "malloc");
692
exitstatus = EX_OSERR;
515
693
goto fallback;
516
694
}
517
695
custom_argv[0] = argv[0];
518
696
custom_argv[1] = NULL;
519
697
520
698
/* for each line in the config file, strip whitespace and ignore
521
699
commented text */
522
700
while(true){
524
702
if(sret == -1){
525
703
break;
526
704
}
527
705
528
706
line = org_line;
529
707
arg = strsep(&line, comment_delim);
530
708
while((p = strsep(&arg, whitespace_delims)) != NULL){
533
711
}
534
712
new_arg = strdup(p);
535
713
if(new_arg == NULL){
536
perror("strdup");
537
exitstatus = EXIT_FAILURE;
714
error(0, errno, "strdup");
715
exitstatus = EX_OSERR;
538
716
free(org_line);
539
717
goto fallback;
540
718
}
541
719
542
720
custom_argc += 1;
543
custom_argv = realloc(custom_argv, sizeof(char *)
544
* ((unsigned int) custom_argc + 1));
545
if(custom_argv == NULL){
546
perror("realloc");
547
exitstatus = EXIT_FAILURE;
548
free(org_line);
549
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
}
550
744
}
551
745
custom_argv[custom_argc-1] = new_arg;
552
custom_argv[custom_argc] = NULL;
746
custom_argv[custom_argc] = NULL;
553
747
}
554
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
}
555
757
free(org_line);
556
} else{
758
} else {
557
759
/* Check for harmful errors and go to fallback. Other errors might
558
760
not affect opening plugins */
559
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
560
perror("fopen");
561
exitstatus = EXIT_FAILURE;
761
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
762
error(0, errno, "fopen");
763
exitstatus = EX_OSERR;
562
764
goto fallback;
563
765
}
564
766
}
565
/* If there was any arguments from configuration file,
566
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 */
567
769
if(custom_argv != NULL){
568
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, NULL);
569
if (ret == ARGP_ERR_UNKNOWN){
570
fprintf(stderr, "Unknown error while parsing arguments\n");
571
exitstatus = EXIT_FAILURE;
572
goto fallback;
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;
784
goto fallback;
785
}
786
}
787
788
/* Parse actual command line arguments, to let them override the
789
config file */
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);
573
822
}
574
823
}
575
824
576
825
if(debug){
577
for(plugin *p = plugin_list; p != NULL; p=p->next){
826
for(plugin *p = plugin_list; p != NULL; p = p->next){
578
827
fprintf(stderr, "Plugin: %s has %d arguments\n",
579
828
p->name ? p->name : "Global", p->argc - 1);
580
829
for(char **a = p->argv; *a != NULL; a++){
581
830
fprintf(stderr, "\tArg: %s\n", *a);
582
831
}
583
fprintf(stderr, "...and %u environment variables\n", p->envc);
832
fprintf(stderr, "...and %d environment variables\n", p->envc);
584
833
for(char **a = p->environ; *a != NULL; a++){
585
834
fprintf(stderr, "\t%s\n", *a);
586
835
}
587
836
}
588
837
}
589
590
/* Strip permissions down to nobody */
838
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
}
591
868
ret = setuid(uid);
592
if (ret == -1){
593
perror("setuid");
594
}
595
setgid(gid);
596
if (ret == -1){
597
perror("setgid");
598
}
599
600
if (plugindir == NULL){
601
dir = opendir(PDIR);
602
} else {
603
dir = opendir(plugindir);
604
}
605
606
if(dir == NULL){
607
perror("Could not open plugin dir");
608
exitstatus = EXIT_FAILURE;
609
goto fallback;
610
}
611
612
/* 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 */
613
874
{
614
int dir_fd = dirfd(dir);
615
if(dir_fd >= 0){
616
ret = set_cloexec_flag(dir_fd);
617
if(ret < 0){
618
perror("set_cloexec_flag");
619
exitstatus = EXIT_FAILURE;
620
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;
621
919
}
622
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;
623
931
}
624
932
625
933
FD_ZERO(&rfds_all);
626
934
627
935
/* Read and execute any executable in the plugin directory*/
628
while(true){
629
dirst = readdir(dir);
630
631
// All directory entries have been processed
632
if(dirst == NULL){
633
if (errno == EBADF){
634
perror("readdir");
635
exitstatus = EXIT_FAILURE;
636
goto fallback;
637
}
638
break;
639
}
640
641
d_name_len = strlen(dirst->d_name);
642
643
// Ignore dotfiles, backup files and other junk
644
{
645
bool bad_name = false;
646
647
const char const *bad_prefixes[] = { ".", "#", NULL };
648
649
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
650
".dpkg-old",
651
".dpkg-divert", NULL };
652
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
653
size_t pre_len = strlen(*pre);
654
if((d_name_len >= pre_len)
655
and strncmp((dirst->d_name), *pre, pre_len) == 0){
656
if(debug){
657
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
658
" with bad prefix %s\n", dirst->d_name, *pre);
659
}
660
bad_name = true;
661
break;
662
}
663
}
664
if(bad_name){
665
continue;
666
}
667
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
668
size_t suf_len = strlen(*suf);
669
if((d_name_len >= suf_len)
670
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
671
== 0)){
672
if(debug){
673
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
674
" with bad suffix %s\n", dirst->d_name, *suf);
675
}
676
bad_name = true;
677
break;
678
}
679
}
680
681
if(bad_name){
682
continue;
683
}
684
}
685
686
char *filename;
687
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
688
if(ret < 0){
689
perror("asprintf");
690
continue;
691
}
692
693
ret = stat(filename, &st);
694
if (ret == -1){
695
perror("stat");
696
free(filename);
697
continue;
698
}
699
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
700
952
/* Ignore non-executable files */
701
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)){
702
956
if(debug){
703
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
704
" 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);
705
961
}
706
free(filename);
962
close(plugin_fd);
963
free(direntries[i]);
707
964
continue;
708
965
}
709
966
710
plugin *p = getplugin(dirst->d_name);
967
plugin *p = getplugin(direntries[i]->d_name);
711
968
if(p == NULL){
712
perror("getplugin");
713
free(filename);
969
error(0, errno, "getplugin");
970
close(plugin_fd);
971
free(direntries[i]);
714
972
continue;
715
973
}
716
974
if(p->disabled){
717
975
if(debug){
718
976
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
719
dirst->d_name);
977
direntries[i]->d_name);
720
978
}
721
free(filename);
979
close(plugin_fd);
980
free(direntries[i]);
722
981
continue;
723
982
}
724
983
{
727
986
if(g != NULL){
728
987
for(char **a = g->argv + 1; *a != NULL; a++){
729
988
if(not add_argument(p, *a)){
730
perror("add_argument");
989
error(0, errno, "add_argument");
731
990
}
732
991
}
733
992
/* Add global environment variables */
734
993
for(char **e = g->environ; *e != NULL; e++){
735
if(not add_environment(p, *e)){
736
perror("add_environment");
994
if(not add_environment(p, *e, false)){
995
error(0, errno, "add_environment");
737
996
}
738
997
}
739
998
}
740
999
}
741
/* If this plugin has any environment variables, we will call
742
using execve and need to duplicate the environment from this
743
process, too. */
1000
/* If this plugin has any environment variables, we need to
1001
duplicate the environment from this process, too. */
744
1002
if(p->environ[0] != NULL){
745
1003
for(char **e = environ; *e != NULL; e++){
746
char *copy = strdup(*e);
747
if(copy == NULL){
748
perror("strdup");
749
continue;
750
}
751
if(not add_environment(p, copy)){
752
perror("add_environment");
1004
if(not add_environment(p, *e, false)){
1005
error(0, errno, "add_environment");
753
1006
}
754
1007
}
755
1008
}
756
1009
757
1010
int pipefd[2];
758
ret = pipe(pipefd);
759
if (ret == -1){
760
perror("pipe");
761
exitstatus = EXIT_FAILURE;
762
goto fallback;
763
}
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
764
1032
/* Ask OS to automatic close the pipe on exec */
765
1033
ret = set_cloexec_flag(pipefd[0]);
766
1034
if(ret < 0){
767
perror("set_cloexec_flag");
768
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]);
769
1040
goto fallback;
770
1041
}
771
1042
ret = set_cloexec_flag(pipefd[1]);
772
1043
if(ret < 0){
773
perror("set_cloexec_flag");
774
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]);
775
1049
goto fallback;
776
1050
}
1051
#endif /* not O_CLOEXEC */
777
1052
/* Block SIGCHLD until process is safely in process list */
778
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));
779
1056
if(ret < 0){
780
perror("sigprocmask");
781
exitstatus = EXIT_FAILURE;
1057
error(0, errno, "sigprocmask");
1058
exitstatus = EX_OSERR;
1059
free(direntries[i]);
782
1060
goto fallback;
783
1061
}
784
// Starting a new process to be watched
785
pid_t pid = fork();
1062
/* Starting a new process to be watched */
1063
pid_t pid;
1064
do {
1065
pid = fork();
1066
} while(pid == -1 and errno == EINTR);
786
1067
if(pid == -1){
787
perror("fork");
788
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]);
789
1075
goto fallback;
790
1076
}
791
1077
if(pid == 0){
792
1078
/* this is the child process */
793
1079
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
794
1080
if(ret < 0){
795
perror("sigaction");
796
_exit(EXIT_FAILURE);
1081
error(0, errno, "sigaction");
1082
_exit(EX_OSERR);
797
1083
}
798
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1084
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
799
1085
if(ret < 0){
800
perror("sigprocmask");
801
_exit(EXIT_FAILURE);
1086
error(0, errno, "sigprocmask");
1087
_exit(EX_OSERR);
802
1088
}
803
1089
804
1090
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
805
1091
if(ret == -1){
806
perror("dup2");
807
_exit(EXIT_FAILURE);
1092
error(0, errno, "dup2");
1093
_exit(EX_OSERR);
808
1094
}
809
1095
810
if(dirfd(dir) < 0){
811
/* If dir has no file descriptor, we could not set FD_CLOEXEC
812
above and must now close it manually here. */
813
closedir(dir);
814
}
815
if(p->environ[0] == NULL){
816
if(execv(filename, p->argv) < 0){
817
perror("execv");
818
_exit(EXIT_FAILURE);
819
}
820
} else {
821
if(execve(filename, p->argv, p->environ) < 0){
822
perror("execve");
823
_exit(EXIT_FAILURE);
824
}
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);
825
1102
}
826
1103
/* no return */
827
1104
}
828
1105
/* Parent process */
829
1106
close(pipefd[1]); /* Close unused write end of pipe */
830
free(filename);
831
plugin *new_plugin = getplugin(dirst->d_name);
832
if (new_plugin == NULL){
833
perror("getplugin");
834
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)));
835
1114
if(ret < 0){
836
perror("sigprocmask");
1115
error(0, errno, "sigprocmask");
837
1116
}
838
exitstatus = EXIT_FAILURE;
1117
exitstatus = EX_OSERR;
1118
free(direntries[i]);
839
1119
goto fallback;
840
1120
}
1121
free(direntries[i]);
841
1122
842
1123
new_plugin->pid = pid;
843
1124
new_plugin->fd = pipefd[0];
844
1125
1126
if(debug){
1127
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1128
new_plugin->name, (intmax_t) (new_plugin->pid));
1129
}
1130
845
1131
/* Unblock SIGCHLD so signal handler can be run if this process
846
1132
has already completed */
847
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));
848
1136
if(ret < 0){
849
perror("sigprocmask");
850
exitstatus = EXIT_FAILURE;
1137
error(0, errno, "sigprocmask");
1138
exitstatus = EX_OSERR;
851
1139
goto fallback;
852
1140
}
853
1141
854
1142
FD_SET(new_plugin->fd, &rfds_all);
855
1143
856
if (maxfd < new_plugin->fd){
1144
if(maxfd < new_plugin->fd){
857
1145
maxfd = new_plugin->fd;
858
1146
}
859
860
1147
}
861
1148
862
closedir(dir);
863
dir = NULL;
864
1149
free(direntries);
1150
direntries = NULL;
1151
close(dir_fd);
1152
dir_fd = -1;
1153
free_plugin(getplugin(NULL));
1154
865
1155
for(plugin *p = plugin_list; p != NULL; p = p->next){
866
1156
if(p->pid != 0){
867
1157
break;
872
1162
free_plugin_list();
873
1163
}
874
1164
}
875
1165
876
1166
/* Main loop while running plugins exist */
877
1167
while(plugin_list){
878
1168
fd_set rfds = rfds_all;
879
1169
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
880
if (select_ret == -1){
881
perror("select");
882
exitstatus = EXIT_FAILURE;
1170
if(select_ret == -1 and errno != EINTR){
1171
error(0, errno, "select");
1172
exitstatus = EX_OSERR;
883
1173
goto fallback;
884
1174
}
885
1175
/* OK, now either a process completed, or something can be read
886
1176
from one of them */
887
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
1177
for(plugin *proc = plugin_list; proc != NULL;){
888
1178
/* Is this process completely done? */
889
if(proc->eof and proc->completed){
1179
if(proc->completed and proc->eof){
890
1180
/* Only accept the plugin output if it exited cleanly */
891
1181
if(not WIFEXITED(proc->status)
892
1182
or WEXITSTATUS(proc->status) != 0){
893
1183
/* Bad exit by plugin */
894
1184
895
1185
if(debug){
896
1186
if(WIFEXITED(proc->status)){
897
fprintf(stderr, "Plugin %u exited with status %d\n",
898
(unsigned int) (proc->pid),
1187
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1188
" status %d\n", proc->name,
1189
(intmax_t) (proc->pid),
899
1190
WEXITSTATUS(proc->status));
900
} else if(WIFSIGNALED(proc->status)) {
901
fprintf(stderr, "Plugin %u killed by signal %d\n",
902
(unsigned int) (proc->pid),
903
WTERMSIG(proc->status));
904
} else if(WCOREDUMP(proc->status)){
905
fprintf(stderr, "Plugin %d dumped core\n",
906
(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)));
907
1197
}
908
1198
}
909
1199
910
1200
/* Remove the plugin */
911
1201
FD_CLR(proc->fd, &rfds_all);
912
1202
913
1203
/* Block signal while modifying process_list */
914
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));
915
1208
if(ret < 0){
916
perror("sigprocmask");
917
exitstatus = EXIT_FAILURE;
1209
error(0, errno, "sigprocmask");
1210
exitstatus = EX_OSERR;
918
1211
goto fallback;
919
1212
}
1213
1214
plugin *next_plugin = proc->next;
920
1215
free_plugin(proc);
1216
proc = next_plugin;
1217
921
1218
/* We are done modifying process list, so unblock signal */
922
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
923
NULL);
1219
ret = (int)(TEMP_FAILURE_RETRY
1220
(sigprocmask(SIG_UNBLOCK,
1221
&sigchld_action.sa_mask, NULL)));
924
1222
if(ret < 0){
925
perror("sigprocmask");
926
exitstatus = EXIT_FAILURE;
1223
error(0, errno, "sigprocmask");
1224
exitstatus = EX_OSERR;
927
1225
goto fallback;
928
1226
}
929
1227
930
1228
if(plugin_list == NULL){
931
1229
break;
932
1230
}
1231
933
1232
continue;
934
1233
}
935
1234
936
1235
/* This process exited nicely, so print its buffer */
937
1236
938
1237
bool bret = print_out_password(proc->buffer,
939
1238
proc->buffer_length);
940
1239
if(not bret){
941
perror("print_out_password");
942
exitstatus = EXIT_FAILURE;
1240
error(0, errno, "print_out_password");
1241
exitstatus = EX_IOERR;
943
1242
}
944
1243
goto fallback;
945
1244
}
947
1246
/* This process has not completed. Does it have any output? */
948
1247
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
949
1248
/* This process had nothing to say at this time */
1249
proc = proc->next;
950
1250
continue;
951
1251
}
952
1252
/* Before reading, make the process' data buffer large enough */
953
1253
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
954
proc->buffer = realloc(proc->buffer, proc->buffer_size
955
+ (size_t) BUFFER_SIZE);
956
if (proc->buffer == NULL){
957
perror("malloc");
958
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;
959
1259
goto fallback;
960
1260
}
1261
proc->buffer = new_buffer;
961
1262
proc->buffer_size += BUFFER_SIZE;
962
1263
}
963
1264
/* Read from the process */
964
ret = read(proc->fd, proc->buffer + proc->buffer_length,
965
BUFFER_SIZE);
966
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){
967
1270
/* Read error from this process; ignore the error */
1271
proc = proc->next;
968
1272
continue;
969
1273
}
970
if(ret == 0){
1274
if(sret == 0){
971
1275
/* got EOF */
972
1276
proc->eof = true;
973
1277
} else {
974
proc->buffer_length += (size_t) ret;
1278
proc->buffer_length += (size_t) sret;
975
1279
}
976
1280
}
977
1281
}
978
979
1282
1283
980
1284
fallback:
981
1285
982
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
1286
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1287
and exitstatus != EX_OK)){
983
1288
/* Fallback if all plugins failed, none are found or an error
984
1289
occured */
985
1290
bool bret;
986
1291
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
987
1292
char *passwordbuffer = getpass("Password: ");
988
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);
989
1300
if(not bret){
990
perror("print_out_password");
991
exitstatus = EXIT_FAILURE;
1301
error(0, errno, "print_out_password");
1302
exitstatus = EX_IOERR;
992
1303
}
993
1304
}
994
1305
995
1306
/* Restore old signal handler */
996
1307
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
997
1308
if(ret == -1){
998
perror("sigaction");
999
exitstatus = EXIT_FAILURE;
1309
error(0, errno, "sigaction");
1310
exitstatus = EX_OSERR;
1000
1311
}
1001
1312
1002
1313
if(custom_argv != NULL){
1003
1314
for(char **arg = custom_argv+1; *arg != NULL; arg++){
1004
1315
free(*arg);
1006
1317
free(custom_argv);
1007
1318
}
1008
1319
1009
if(dir != NULL){
1010
closedir(dir);
1320
free(direntries);
1321
1322
if(dir_fd != -1){
1323
close(dir_fd);
1011
1324
}
1012
1325
1013
/* Free the process list and kill the processes */
1326
/* Kill the processes */
1014
1327
for(plugin *p = plugin_list; p != NULL; p = p->next){
1015
1328
if(p->pid != 0){
1016
1329
close(p->fd);
1017
1330
ret = kill(p->pid, SIGTERM);
1018
1331
if(ret == -1 and errno != ESRCH){
1019
1332
/* Set-uid proccesses might not get closed */
1020
perror("kill");
1333
error(0, errno, "kill");
1021
1334
}
1022
1335
}
1023
1336
}
1024
1337
1025
1338
/* Wait for any remaining child processes to terminate */
1026
do{
1339
do {
1027
1340
ret = wait(NULL);
1028
1341
} while(ret >= 0);
1029
1342
if(errno != ECHILD){
1030
perror("wait");
1343
error(0, errno, "wait");
1031
1344
}
1032
1345
1033
1346
free_plugin_list();
1034
1347
1035
1348
free(plugindir);
1349
free(pluginhelperdir);
1036
1350
free(argfile);
1037
1351
1038
1352
return exitstatus;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0