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