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