To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugin-runner.c
- browse files at revision 237.7.325
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.325
- Committer: Teddy Hogeborn
- Date: 2015-07-20 03:03:33 UTC
- mto: (237.7.594 trunk)
- mto: This revision was merged to the branch mainline in revision 325.
- Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.
The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string. This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:
SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256
* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
(/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.
The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string. This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:
SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256
* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
(/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.
- 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-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 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
* ((unsigned int)
705
custom_argc + 1));
706
if(new_argv == NULL){
707
error(0, errno, "realloc");
708
exitstatus = EX_OSERR;
709
free(new_arg);
710
free(org_line);
711
goto fallback;
712
} else {
713
custom_argv = new_argv;
714
}
715
}
716
custom_argv[custom_argc-1] = new_arg;
717
custom_argv[custom_argc] = NULL;
485
718
}
486
719
}
720
do {
721
ret = fclose(conffp);
722
} while(ret == EOF and errno == EINTR);
723
if(ret == EOF){
724
error(0, errno, "fclose");
725
exitstatus = EX_IOERR;
726
goto fallback;
727
}
487
728
free(org_line);
488
} else{
729
} else {
489
730
/* Check for harmful errors and go to fallback. Other errors might
490
731
not affect opening plugins */
491
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
492
perror("fopen");
493
exitstatus = EXIT_FAILURE;
732
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
733
error(0, errno, "fopen");
734
exitstatus = EX_OSERR;
494
735
goto fallback;
495
736
}
496
737
}
497
738
/* If there were any arguments from the configuration file, pass
739
them to parser as command line arguments */
498
740
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;
741
ret = argp_parse(&argp, custom_argc, custom_argv,
742
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
743
NULL, NULL);
744
switch(ret){
745
case 0:
746
break;
747
case ENOMEM:
748
default:
749
errno = ret;
750
error(0, errno, "argp_parse");
751
exitstatus = EX_OSERR;
752
goto fallback;
753
case EINVAL:
754
exitstatus = EX_CONFIG;
755
goto fallback;
756
}
757
}
758
759
/* Parse actual command line arguments, to let them override the
760
config file */
761
ret = argp_parse(&argp, argc, argv,
762
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
763
NULL, NULL);
764
switch(ret){
765
case 0:
766
break;
767
case ENOMEM:
768
default:
769
errno = ret;
770
error(0, errno, "argp_parse");
771
exitstatus = EX_OSERR;
772
goto fallback;
773
case EINVAL:
774
exitstatus = EX_USAGE;
775
goto fallback;
776
}
777
778
{
779
char *pluginhelperenv;
780
bool bret = true;
781
ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
782
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
783
if(ret != -1){
784
bret = add_environment(getplugin(NULL), pluginhelperenv, true);
785
}
786
if(ret == -1 or not bret){
787
error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
788
" environment variable to \"%s\" for all plugins\n",
789
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
790
}
791
if(ret != -1){
792
free(pluginhelperenv);
505
793
}
506
794
}
507
795
512
800
for(char **a = p->argv; *a != NULL; a++){
513
801
fprintf(stderr, "\tArg: %s\n", *a);
514
802
}
515
fprintf(stderr, "...and %u environment variables\n", p->envc);
803
fprintf(stderr, "...and %d environment variables\n", p->envc);
516
804
for(char **a = p->environ; *a != NULL; a++){
517
805
fprintf(stderr, "\t%s\n", *a);
518
806
}
519
807
}
520
808
}
521
809
810
if(getuid() == 0){
811
/* Work around Debian bug #633582:
812
<http://bugs.debian.org/633582> */
813
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
814
if(plugindir_fd == -1){
815
if(errno != ENOENT){
816
error(0, errno, "open(\"" PDIR "\")");
817
}
818
} else {
819
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
820
if(ret == -1){
821
error(0, errno, "fstat");
822
} else {
823
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
824
ret = fchown(plugindir_fd, uid, gid);
825
if(ret == -1){
826
error(0, errno, "fchown");
827
}
828
}
829
}
830
close(plugindir_fd);
831
}
832
}
833
834
/* Lower permissions */
835
ret = setgid(gid);
836
if(ret == -1){
837
error(0, errno, "setgid");
838
}
522
839
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 */
840
if(ret == -1){
841
error(0, errno, "setuid");
842
}
843
844
/* Open plugin directory with close_on_exec flag */
540
845
{
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;
846
dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
847
#ifdef O_CLOEXEC
848
O_CLOEXEC
849
#else /* not O_CLOEXEC */
850
0
851
#endif /* not O_CLOEXEC */
852
);
853
if(dir_fd == -1){
854
error(0, errno, "Could not open plugin dir");
855
exitstatus = EX_UNAVAILABLE;
856
goto fallback;
857
}
858
859
#ifndef O_CLOEXEC
860
/* Set the FD_CLOEXEC flag on the directory */
861
ret = set_cloexec_flag(dir_fd);
862
if(ret < 0){
863
error(0, errno, "set_cloexec_flag");
864
exitstatus = EX_OSERR;
865
goto fallback;
866
}
867
#endif /* O_CLOEXEC */
868
}
869
870
int good_name(const struct dirent * const dirent){
871
const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
872
"*.dpkg-old", "*.dpkg-bak",
873
"*.dpkg-divert", NULL };
874
#ifdef __GNUC__
875
#pragma GCC diagnostic push
876
#pragma GCC diagnostic ignored "-Wcast-qual"
877
#endif
878
for(const char **pat = (const char **)patterns;
879
*pat != NULL; pat++){
880
#ifdef __GNUC__
881
#pragma GCC diagnostic pop
882
#endif
883
if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
884
!= FNM_NOMATCH){
885
if(debug){
886
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
887
" matching pattern %s\n", dirent->d_name, *pat);
888
}
889
return 0;
548
890
}
549
891
}
892
return 1;
893
}
894
895
#ifdef __GLIBC__
896
#if __GLIBC_PREREQ(2, 15)
897
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
898
alphasort);
899
#else /* not __GLIBC_PREREQ(2, 15) */
900
int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
901
&direntries, good_name, alphasort);
902
#endif /* not __GLIBC_PREREQ(2, 15) */
903
#else /* not __GLIBC__ */
904
int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
905
&direntries, good_name, alphasort);
906
#endif /* not __GLIBC__ */
907
if(numplugins == -1){
908
error(0, errno, "Could not scan plugin dir");
909
direntries = NULL;
910
exitstatus = EX_OSERR;
911
goto fallback;
550
912
}
551
913
552
914
FD_ZERO(&rfds_all);
553
915
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)){
916
/* Read and execute any executable in the plugin directory*/
917
for(int i = 0; i < numplugins; i++){
918
919
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
920
if(plugin_fd == -1){
921
error(0, errno, "Could not open plugin");
922
free(direntries[i]);
923
continue;
924
}
925
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
926
if(ret == -1){
927
error(0, errno, "stat");
928
close(plugin_fd);
929
free(direntries[i]);
930
continue;
931
}
932
933
/* Ignore non-executable files */
934
if(not S_ISREG(st.st_mode)
935
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
936
X_OK, 0)) != 0)){
629
937
if(debug){
630
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
631
" with bad type or mode\n", filename);
938
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
939
" with bad type or mode\n",
940
plugindir != NULL ? plugindir : PDIR,
941
direntries[i]->d_name);
632
942
}
633
free(filename);
943
close(plugin_fd);
944
free(direntries[i]);
634
945
continue;
635
946
}
636
plugin *p = getplugin(dirst->d_name, &plugin_list);
947
948
plugin *p = getplugin(direntries[i]->d_name);
637
949
if(p == NULL){
638
perror("getplugin");
639
free(filename);
950
error(0, errno, "getplugin");
951
close(plugin_fd);
952
free(direntries[i]);
640
953
continue;
641
954
}
642
955
if(p->disabled){
643
956
if(debug){
644
957
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
645
dirst->d_name);
958
direntries[i]->d_name);
646
959
}
647
free(filename);
960
close(plugin_fd);
961
free(direntries[i]);
648
962
continue;
649
963
}
650
964
{
651
965
/* Add global arguments to argument list for this plugin */
652
plugin *g = getplugin(NULL, &plugin_list);
966
plugin *g = getplugin(NULL);
653
967
if(g != NULL){
654
968
for(char **a = g->argv + 1; *a != NULL; a++){
655
969
if(not add_argument(p, *a)){
656
perror("add_argument");
970
error(0, errno, "add_argument");
657
971
}
658
972
}
659
973
/* Add global environment variables */
660
974
for(char **e = g->environ; *e != NULL; e++){
661
if(not add_environment(p, *e)){
662
perror("add_environment");
975
if(not add_environment(p, *e, false)){
976
error(0, errno, "add_environment");
663
977
}
664
978
}
665
979
}
666
980
}
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. */
981
/* If this plugin has any environment variables, we need to
982
duplicate the environment from this process, too. */
670
983
if(p->environ[0] != NULL){
671
984
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");
985
if(not add_environment(p, *e, false)){
986
error(0, errno, "add_environment");
679
987
}
680
988
}
681
989
}
682
990
683
int pipefd[2];
684
ret = pipe(pipefd);
685
if (ret == -1){
686
perror("pipe");
687
exitstatus = EXIT_FAILURE;
688
goto fallback;
689
}
991
int pipefd[2];
992
#ifndef O_CLOEXEC
993
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
994
#else /* O_CLOEXEC */
995
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
996
#endif /* O_CLOEXEC */
997
if(ret == -1){
998
error(0, errno, "pipe");
999
exitstatus = EX_OSERR;
1000
free(direntries[i]);
1001
goto fallback;
1002
}
1003
if(pipefd[0] >= FD_SETSIZE){
1004
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1005
FD_SETSIZE);
1006
close(pipefd[0]);
1007
close(pipefd[1]);
1008
exitstatus = EX_OSERR;
1009
free(direntries[i]);
1010
goto fallback;
1011
}
1012
#ifndef O_CLOEXEC
1013
/* Ask OS to automatic close the pipe on exec */
690
1014
ret = set_cloexec_flag(pipefd[0]);
691
1015
if(ret < 0){
692
perror("set_cloexec_flag");
693
exitstatus = EXIT_FAILURE;
1016
error(0, errno, "set_cloexec_flag");
1017
close(pipefd[0]);
1018
close(pipefd[1]);
1019
exitstatus = EX_OSERR;
1020
free(direntries[i]);
694
1021
goto fallback;
695
1022
}
696
1023
ret = set_cloexec_flag(pipefd[1]);
697
1024
if(ret < 0){
698
perror("set_cloexec_flag");
699
exitstatus = EXIT_FAILURE;
1025
error(0, errno, "set_cloexec_flag");
1026
close(pipefd[0]);
1027
close(pipefd[1]);
1028
exitstatus = EX_OSERR;
1029
free(direntries[i]);
700
1030
goto fallback;
701
1031
}
1032
#endif /* not O_CLOEXEC */
702
1033
/* Block SIGCHLD until process is safely in process list */
703
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1034
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1035
&sigchld_action.sa_mask,
1036
NULL));
704
1037
if(ret < 0){
705
perror("sigprocmask");
706
exitstatus = EXIT_FAILURE;
1038
error(0, errno, "sigprocmask");
1039
exitstatus = EX_OSERR;
1040
free(direntries[i]);
707
1041
goto fallback;
708
1042
}
709
// Starting a new process to be watched
710
pid_t pid = fork();
1043
/* Starting a new process to be watched */
1044
pid_t pid;
1045
do {
1046
pid = fork();
1047
} while(pid == -1 and errno == EINTR);
711
1048
if(pid == -1){
712
perror("fork");
713
exitstatus = EXIT_FAILURE;
1049
error(0, errno, "fork");
1050
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1051
&sigchld_action.sa_mask, NULL));
1052
close(pipefd[0]);
1053
close(pipefd[1]);
1054
exitstatus = EX_OSERR;
1055
free(direntries[i]);
714
1056
goto fallback;
715
1057
}
716
1058
if(pid == 0){
717
1059
/* this is the child process */
718
1060
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
719
1061
if(ret < 0){
720
perror("sigaction");
721
_exit(EXIT_FAILURE);
1062
error(0, errno, "sigaction");
1063
_exit(EX_OSERR);
722
1064
}
723
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1065
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
724
1066
if(ret < 0){
725
perror("sigprocmask");
726
_exit(EXIT_FAILURE);
1067
error(0, errno, "sigprocmask");
1068
_exit(EX_OSERR);
727
1069
}
728
1070
729
1071
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
730
1072
if(ret == -1){
731
perror("dup2");
732
_exit(EXIT_FAILURE);
1073
error(0, errno, "dup2");
1074
_exit(EX_OSERR);
733
1075
}
734
1076
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
}
1077
if(fexecve(plugin_fd, p->argv,
1078
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1079
error(0, errno, "fexecve for %s/%s",
1080
plugindir != NULL ? plugindir : PDIR,
1081
direntries[i]->d_name);
1082
_exit(EX_OSERR);
750
1083
}
751
1084
/* no return */
752
1085
}
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);
1086
/* Parent process */
1087
close(pipefd[1]); /* Close unused write end of pipe */
1088
close(plugin_fd);
1089
plugin *new_plugin = getplugin(direntries[i]->d_name);
1090
if(new_plugin == NULL){
1091
error(0, errno, "getplugin");
1092
ret = (int)(TEMP_FAILURE_RETRY
1093
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1094
NULL)));
760
1095
if(ret < 0){
761
perror("sigprocmask");
1096
error(0, errno, "sigprocmask");
762
1097
}
763
exitstatus = EXIT_FAILURE;
1098
exitstatus = EX_OSERR;
1099
free(direntries[i]);
764
1100
goto fallback;
765
1101
}
766
767
*new_process = (struct process){ .pid = pid,
768
.fd = pipefd[0],
769
.next = process_list };
770
// List handling
771
process_list = new_process;
1102
free(direntries[i]);
1103
1104
new_plugin->pid = pid;
1105
new_plugin->fd = pipefd[0];
1106
772
1107
/* Unblock SIGCHLD so signal handler can be run if this process
773
1108
has already completed */
774
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1109
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1110
&sigchld_action.sa_mask,
1111
NULL));
775
1112
if(ret < 0){
776
perror("sigprocmask");
777
exitstatus = EXIT_FAILURE;
1113
error(0, errno, "sigprocmask");
1114
exitstatus = EX_OSERR;
778
1115
goto fallback;
779
1116
}
780
1117
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){
1118
#if defined (__GNUC__) and defined (__GLIBC__)
1119
#if not __GLIBC_PREREQ(2, 16)
1120
#pragma GCC diagnostic push
1121
#pragma GCC diagnostic ignored "-Wsign-conversion"
1122
#endif
1123
#endif
1124
FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1125
-Wconversion in GNU libc
1126
before 2.16 */
1127
#if defined (__GNUC__) and defined (__GLIBC__)
1128
#if not __GLIBC_PREREQ(2, 16)
1129
#pragma GCC diagnostic pop
1130
#endif
1131
#endif
1132
1133
if(maxfd < new_plugin->fd){
1134
maxfd = new_plugin->fd;
1135
}
1136
}
1137
1138
free(direntries);
1139
direntries = NULL;
1140
close(dir_fd);
1141
dir_fd = -1;
1142
free_plugin(getplugin(NULL));
1143
1144
for(plugin *p = plugin_list; p != NULL; p = p->next){
1145
if(p->pid != 0){
1146
break;
1147
}
1148
if(p->next == NULL){
1149
fprintf(stderr, "No plugin processes started. Incorrect plugin"
1150
" directory?\n");
1151
free_plugin_list();
1152
}
1153
}
1154
1155
/* Main loop while running plugins exist */
1156
while(plugin_list){
800
1157
fd_set rfds = rfds_all;
801
1158
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
802
if (select_ret == -1){
803
perror("select");
804
exitstatus = EXIT_FAILURE;
1159
if(select_ret == -1 and errno != EINTR){
1160
error(0, errno, "select");
1161
exitstatus = EX_OSERR;
805
1162
goto fallback;
806
1163
}
807
1164
/* OK, now either a process completed, or something can be read
808
1165
from one of them */
809
for(process *proc = process_list; proc ; proc = proc->next){
1166
for(plugin *proc = plugin_list; proc != NULL;){
810
1167
/* Is this process completely done? */
811
if(proc->eof and proc->completed){
1168
if(proc->completed and proc->eof){
812
1169
/* Only accept the plugin output if it exited cleanly */
813
1170
if(not WIFEXITED(proc->status)
814
1171
or WEXITSTATUS(proc->status) != 0){
815
1172
/* Bad exit by plugin */
1173
816
1174
if(debug){
817
1175
if(WIFEXITED(proc->status)){
818
fprintf(stderr, "Plugin %u exited with status %d\n",
819
(unsigned int) (proc->pid),
1176
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1177
" status %d\n", proc->name,
1178
(intmax_t) (proc->pid),
820
1179
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));
1180
} else if(WIFSIGNALED(proc->status)){
1181
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1182
" signal %d: %s\n", proc->name,
1183
(intmax_t) (proc->pid),
1184
WTERMSIG(proc->status),
1185
strsignal(WTERMSIG(proc->status)));
825
1186
} else if(WCOREDUMP(proc->status)){
826
fprintf(stderr, "Plugin %d dumped core\n",
827
(unsigned int) (proc->pid));
1187
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1188
" core\n", proc->name, (intmax_t) (proc->pid));
828
1189
}
829
1190
}
1191
830
1192
/* Remove the plugin */
831
FD_CLR(proc->fd, &rfds_all);
1193
#if defined (__GNUC__) and defined (__GLIBC__)
1194
#if not __GLIBC_PREREQ(2, 16)
1195
#pragma GCC diagnostic push
1196
#pragma GCC diagnostic ignored "-Wsign-conversion"
1197
#endif
1198
#endif
1199
FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1200
-Wconversion in GNU libc
1201
before 2.16 */
1202
#if defined (__GNUC__) and defined (__GLIBC__)
1203
#if not __GLIBC_PREREQ(2, 16)
1204
#pragma GCC diagnostic pop
1205
#endif
1206
#endif
1207
832
1208
/* Block signal while modifying process_list */
833
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1209
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1210
(SIG_BLOCK,
1211
&sigchld_action.sa_mask,
1212
NULL));
834
1213
if(ret < 0){
835
perror("sigprocmask");
836
exitstatus = EXIT_FAILURE;
1214
error(0, errno, "sigprocmask");
1215
exitstatus = EX_OSERR;
837
1216
goto fallback;
838
1217
}
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
}
1218
1219
plugin *next_plugin = proc->next;
1220
free_plugin(proc);
1221
proc = next_plugin;
1222
852
1223
/* We are done modifying process list, so unblock signal */
853
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
854
NULL);
1224
ret = (int)(TEMP_FAILURE_RETRY
1225
(sigprocmask(SIG_UNBLOCK,
1226
&sigchld_action.sa_mask, NULL)));
855
1227
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;
1228
error(0, errno, "sigprocmask");
1229
exitstatus = EX_OSERR;
1230
goto fallback;
1231
}
1232
1233
if(plugin_list == NULL){
1234
break;
1235
}
1236
1237
continue;
864
1238
}
1239
865
1240
/* This process exited nicely, so print its buffer */
866
867
bool bret = print_out_password(proc->buffer, proc->buffer_length);
1241
1242
bool bret = print_out_password(proc->buffer,
1243
proc->buffer_length);
868
1244
if(not bret){
869
perror("print_out_password");
870
exitstatus = EXIT_FAILURE;
1245
error(0, errno, "print_out_password");
1246
exitstatus = EX_IOERR;
871
1247
}
872
1248
goto fallback;
873
1249
}
1250
874
1251
/* This process has not completed. Does it have any output? */
875
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1252
#if defined (__GNUC__) and defined (__GLIBC__)
1253
#if not __GLIBC_PREREQ(2, 16)
1254
#pragma GCC diagnostic push
1255
#pragma GCC diagnostic ignored "-Wsign-conversion"
1256
#endif
1257
#endif
1258
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1259
warning from
1260
-Wconversion
1261
in GNU libc
1262
before
1263
2.16 */
1264
#if defined (__GNUC__) and defined (__GLIBC__)
1265
#if not __GLIBC_PREREQ(2, 16)
1266
#pragma GCC diagnostic pop
1267
#endif
1268
#endif
876
1269
/* This process had nothing to say at this time */
1270
proc = proc->next;
877
1271
continue;
878
1272
}
879
1273
/* Before reading, make the process' data buffer large enough */
880
1274
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;
1275
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1276
+ (size_t) BUFFER_SIZE);
1277
if(new_buffer == NULL){
1278
error(0, errno, "malloc");
1279
exitstatus = EX_OSERR;
886
1280
goto fallback;
887
1281
}
1282
proc->buffer = new_buffer;
888
1283
proc->buffer_size += BUFFER_SIZE;
889
1284
}
890
1285
/* Read from the process */
891
ret = read(proc->fd, proc->buffer + proc->buffer_length,
892
BUFFER_SIZE);
893
if(ret < 0){
1286
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1287
proc->buffer
1288
+ proc->buffer_length,
1289
BUFFER_SIZE));
1290
if(sret < 0){
894
1291
/* Read error from this process; ignore the error */
1292
proc = proc->next;
895
1293
continue;
896
1294
}
897
if(ret == 0){
1295
if(sret == 0){
898
1296
/* got EOF */
899
1297
proc->eof = true;
900
1298
} else {
901
proc->buffer_length += (size_t) ret;
1299
proc->buffer_length += (size_t) sret;
902
1300
}
903
1301
}
904
1302
}
905
906
1303
1304
907
1305
fallback:
908
1306
909
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
910
/* Fallback if all plugins failed, none are found or an error occured */
1307
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1308
and exitstatus != EX_OK)){
1309
/* Fallback if all plugins failed, none are found or an error
1310
occured */
911
1311
bool bret;
912
1312
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
913
1313
char *passwordbuffer = getpass("Password: ");
914
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
1314
size_t len = strlen(passwordbuffer);
1315
/* Strip trailing newline */
1316
if(len > 0 and passwordbuffer[len-1] == '\n'){
1317
passwordbuffer[len-1] = '\0'; /* not strictly necessary */
1318
len--;
1319
}
1320
bret = print_out_password(passwordbuffer, len);
915
1321
if(not bret){
916
perror("print_out_password");
917
exitstatus = EXIT_FAILURE;
1322
error(0, errno, "print_out_password");
1323
exitstatus = EX_IOERR;
918
1324
}
919
1325
}
920
1326
921
1327
/* Restore old signal handler */
922
1328
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
923
1329
if(ret == -1){
924
perror("sigaction");
925
exitstatus = EXIT_FAILURE;
1330
error(0, errno, "sigaction");
1331
exitstatus = EX_OSERR;
926
1332
}
927
1333
928
1334
if(custom_argv != NULL){
929
for(char **arg = custom_argv; *arg != NULL; arg++){
1335
for(char **arg = custom_argv+1; *arg != NULL; arg++){
930
1336
free(*arg);
931
1337
}
932
1338
free(custom_argv);
933
1339
}
934
free_plugin_list(plugin_list);
935
936
if(dir != NULL){
937
closedir(dir);
1340
1341
free(direntries);
1342
1343
if(dir_fd != -1){
1344
close(dir_fd);
938
1345
}
939
1346
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");
1347
/* Kill the processes */
1348
for(plugin *p = plugin_list; p != NULL; p = p->next){
1349
if(p->pid != 0){
1350
close(p->fd);
1351
ret = kill(p->pid, SIGTERM);
1352
if(ret == -1 and errno != ESRCH){
1353
/* Set-uid proccesses might not get closed */
1354
error(0, errno, "kill");
1355
}
948
1356
}
949
free(process_list->buffer);
950
free(process_list);
951
1357
}
952
1358
953
1359
/* Wait for any remaining child processes to terminate */
954
do{
1360
do {
955
1361
ret = wait(NULL);
956
1362
} while(ret >= 0);
957
1363
if(errno != ECHILD){
958
perror("wait");
1364
error(0, errno, "wait");
959
1365
}
960
1366
1367
free_plugin_list();
1368
1369
free(plugindir);
1370
free(pluginhelperdir);
1371
free(argfile);
1372
961
1373
return exitstatus;
962
1374
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0