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