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