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