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