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