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