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