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