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