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