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.23.4
- compare with another revision
- download diff
- download tarball
- view history from revision 237.23.4
- Committer: Teddy Hogeborn
- Date: 2014-07-25 23:16:04 UTC
- mto: (237.7.272 trunk)
- mto: This revision was merged to the branch mainline in revision 321.
- Revision ID: teddy@recompile.se-20140725231604-f5c4f82rn2o5ll1k
Use the .items() method instead of .iteritems().
This is strictly not a Python 2.7 change, but Python 2.7 backported
the new .viewitems() from Python 3, and instead of changing .items()
to .viewitems() and later having to change them all into .items()
again in Python 3, I opted to just change all .iteritems() to .items()
so the code will work both now and with Python 3. The slowdown with
Python 2 is not significant, and with Python 3 it will again be fast.
* mandos (Client.__init__): Use .items() instead of .iteritems().
(DBusObjectWithProperties.Introspect): - '' -
(alternate_dbus_interfaces/wrapper): - '' -
(main): - '' -
* mandos-ctl (main): - '' -
This is strictly not a Python 2.7 change, but Python 2.7 backported
the new .viewitems() from Python 3, and instead of changing .items()
to .viewitems() and later having to change them all into .items()
again in Python 3, I opted to just change all .iteritems() to .items()
so the code will work both now and with Python 3. The slowdown with
Python 2 is not significant, and with Python 3 it will again be fast.
* mandos (Client.__init__): Use .items() instead of .iteritems().
(DBusObjectWithProperties.Introspect): - '' -
(alternate_dbus_interfaces/wrapper): - '' -
(main): - '' -
* mandos-ctl (main): - '' -
- 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,
61
63
#include <signal.h> /* struct sigaction, sigemptyset(),
62
64
sigaddset(), sigaction(),
63
65
sigprocmask(), SIG_BLOCK, SIGCHLD,
64
SIG_UNBLOCK, kill() */
66
SIG_UNBLOCK, kill(), sig_atomic_t
67
*/
65
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() */
66
75
67
76
#define BUFFER_SIZE 256
68
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
69
70
const char *argp_program_version = "plugin-runner 1.0";
71
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
72
73
struct process;
74
75
typedef struct process{
76
pid_t pid;
77
int fd;
78
char *buffer;
79
size_t buffer_size;
80
size_t buffer_length;
81
bool eof;
82
volatile bool completed;
83
volatile int status;
84
struct process *next;
85
} process;
77
78
#define PDIR "/lib/mandos/plugins.d"
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
81
const char *argp_program_version = "plugin-runner " VERSION;
82
const char *argp_program_bug_address = "<mandos@recompile.se>";
86
83
87
84
typedef struct plugin{
88
85
char *name; /* can be NULL or any plugin name */
91
88
char **environ;
92
89
int envc;
93
90
bool disabled;
91
92
/* Variables used for running processes*/
93
pid_t pid;
94
int fd;
95
char *buffer;
96
size_t buffer_size;
97
size_t buffer_length;
98
bool eof;
99
volatile sig_atomic_t completed;
100
int status;
94
101
struct plugin *next;
95
102
} plugin;
96
103
97
static plugin *getplugin(char *name, plugin **plugin_list){
98
for (plugin *p = *plugin_list; p != NULL; p = p->next){
99
if ((p->name == name)
100
or (p->name and name and (strcmp(p->name, name) == 0))){
104
static plugin *plugin_list = NULL;
105
106
/* Gets an existing plugin based on name,
107
or if none is found, creates a new one */
108
__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))){
101
114
return p;
102
115
}
103
116
}
104
117
/* Create a new plugin */
105
plugin *new_plugin = malloc(sizeof(plugin));
106
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){
107
123
return NULL;
108
124
}
109
125
char *copy_name = NULL;
110
126
if(name != NULL){
111
copy_name = strdup(name);
127
do {
128
copy_name = strdup(name);
129
} while(copy_name == NULL and errno == EINTR);
112
130
if(copy_name == NULL){
131
int e = errno;
132
free(new_plugin);
133
errno = e;
113
134
return NULL;
114
135
}
115
136
}
116
137
117
*new_plugin = (plugin) { .name = copy_name,
118
.argc = 1,
119
.envc = 0,
120
.disabled = false,
121
.next = *plugin_list };
138
*new_plugin = (plugin){ .name = copy_name,
139
.argc = 1,
140
.disabled = false,
141
.next = plugin_list };
122
142
123
new_plugin->argv = malloc(sizeof(char *) * 2);
124
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;
125
148
free(copy_name);
126
149
free(new_plugin);
150
errno = e;
127
151
return NULL;
128
152
}
129
153
new_plugin->argv[0] = copy_name;
130
154
new_plugin->argv[1] = NULL;
131
132
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);
133
159
if(new_plugin->environ == NULL){
160
int e = errno;
134
161
free(copy_name);
135
162
free(new_plugin->argv);
136
163
free(new_plugin);
164
errno = e;
137
165
return NULL;
138
166
}
139
167
new_plugin->environ[0] = NULL;
168
140
169
/* Append the new plugin to the list */
141
*plugin_list = new_plugin;
170
plugin_list = new_plugin;
142
171
return new_plugin;
143
172
}
144
173
145
174
/* Helper function for add_argument and add_environment */
175
__attribute__((nonnull, warn_unused_result))
146
176
static bool add_to_char_array(const char *new, char ***array,
147
177
int *len){
148
178
/* Resize the pointed-to array to hold one more pointer */
149
*array = realloc(*array, sizeof(char *)
150
* (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);
151
184
/* Malloc check */
152
if(*array == NULL){
185
if(new_array == NULL){
153
186
return false;
154
187
}
188
*array = new_array;
155
189
/* Make a copy of the new string */
156
char *copy = strdup(new);
190
char *copy;
191
do {
192
copy = strdup(new);
193
} while(copy == NULL and errno == EINTR);
157
194
if(copy == NULL){
158
195
return false;
159
196
}
166
203
}
167
204
168
205
/* Add to a plugin's argument vector */
206
__attribute__((nonnull(2), warn_unused_result))
169
207
static bool add_argument(plugin *p, const char *arg){
170
208
if(p == NULL){
171
209
return false;
174
212
}
175
213
176
214
/* Add to a plugin's environment */
177
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){
178
217
if(p == NULL){
179
218
return false;
180
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
}
181
240
return add_to_char_array(def, &(p->environ), &(p->envc));
182
241
}
183
242
184
243
#ifndef O_CLOEXEC
185
244
/*
186
245
* Based on the example in the GNU LibC manual chapter 13.13 "File
187
246
* Descriptor Flags".
188
* *Note File Descriptor Flags:(libc)Descriptor Flags.
247
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
189
248
*/
190
static int set_cloexec_flag(int fd)
191
{
192
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));
193
252
/* If reading the flags failed, return error indication now. */
194
253
if(ret < 0){
195
254
return ret;
196
255
}
197
256
/* Store modified flag word in the descriptor. */
198
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
257
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
258
ret | FD_CLOEXEC));
199
259
}
260
#endif /* not O_CLOEXEC */
200
261
201
process *process_list = NULL;
202
262
203
263
/* Mark processes as completed when they exit, and save their exit
204
264
status. */
205
void handle_sigchld(__attribute__((unused)) int sig){
265
static void handle_sigchld(__attribute__((unused)) int sig){
266
int old_errno = errno;
206
267
while(true){
207
process *proc = process_list;
268
plugin *proc = plugin_list;
208
269
int status;
209
270
pid_t pid = waitpid(-1, &status, WNOHANG);
210
271
if(pid == 0){
212
273
break;
213
274
}
214
275
if(pid == -1){
215
if (errno != ECHILD){
216
perror("waitpid");
276
if(errno == ECHILD){
277
/* No child processes */
278
break;
217
279
}
218
/* No child processes */
219
break;
280
error(0, errno, "waitpid");
220
281
}
221
282
222
283
/* A child exited, find it in process_list */
223
284
while(proc != NULL and proc->pid != pid){
224
285
proc = proc->next;
228
289
continue;
229
290
}
230
291
proc->status = status;
231
proc->completed = true;
292
proc->completed = 1;
232
293
}
294
errno = old_errno;
233
295
}
234
296
235
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){
236
300
ssize_t ret;
237
if(length>0 and buffer[length-1] == '\n'){
238
length--;
239
}
240
301
for(size_t written = 0; written < length; written += (size_t)ret){
241
302
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
242
303
length - written));
247
308
return true;
248
309
}
249
310
250
char **add_to_argv(char **argv, int *argc, char *arg){
251
if (argv == NULL){
252
*argc = 1;
253
argv = malloc(sizeof(char*) * 2);
254
if(argv == NULL){
255
return NULL;
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
}
256
336
}
257
argv[0] = NULL; /* Will be set to argv[0] in main before
258
parsing */
259
argv[1] = NULL;
260
}
261
*argc += 1;
262
argv = realloc(argv, sizeof(char *)
263
* ((unsigned int) *argc + 1));
264
if(argv == NULL){
265
return NULL;
266
}
267
argv[*argc-1] = arg;
268
argv[*argc] = NULL;
269
return argv;
337
}
338
339
free(plugin_node);
270
340
}
271
341
272
static void free_plugin_list(plugin *plugin_list){
273
for(plugin *next; plugin_list != NULL; plugin_list = next){
274
next = plugin_list->next;
275
for(char **arg = plugin_list->argv; *arg != NULL; arg++){
276
free(*arg);
277
}
278
free(plugin_list->argv);
279
for(char **env = plugin_list->environ; *env != NULL; env++){
280
free(*env);
281
}
282
free(plugin_list->environ);
283
free(plugin_list);
342
static void free_plugin_list(void){
343
while(plugin_list != NULL){
344
free_plugin(plugin_list);
284
345
}
285
346
}
286
347
287
348
int main(int argc, char *argv[]){
288
const char *plugindir = "/lib/mandos/plugins.d";
289
const char *argfile = ARGFILE;
349
char *plugindir = NULL;
350
char *argfile = NULL;
290
351
FILE *conffp;
291
size_t d_name_len;
292
DIR *dir = NULL;
293
struct dirent *dirst;
352
struct dirent **direntries = NULL;
294
353
struct stat st;
295
354
fd_set rfds_all;
296
355
int ret, maxfd = 0;
356
ssize_t sret;
297
357
uid_t uid = 65534;
298
358
gid_t gid = 65534;
299
359
bool debug = false;
303
363
.sa_flags = SA_NOCLDSTOP };
304
364
char **custom_argv = NULL;
305
365
int custom_argc = 0;
366
int dir_fd = -1;
306
367
307
368
/* Establish a signal handler */
308
369
sigemptyset(&sigchld_action.sa_mask);
309
370
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
310
371
if(ret == -1){
311
perror("sigaddset");
312
exitstatus = EXIT_FAILURE;
372
error(0, errno, "sigaddset");
373
exitstatus = EX_OSERR;
313
374
goto fallback;
314
375
}
315
376
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
316
377
if(ret == -1){
317
perror("sigaction");
318
exitstatus = EXIT_FAILURE;
378
error(0, errno, "sigaction");
379
exitstatus = EX_OSERR;
319
380
goto fallback;
320
381
}
321
382
324
385
{ .name = "global-options", .key = 'g',
325
386
.arg = "OPTION[,OPTION[,...]]",
326
387
.doc = "Options passed to all plugins" },
327
{ .name = "global-envs", .key = 'e',
388
{ .name = "global-env", .key = 'G',
328
389
.arg = "VAR=value",
329
390
.doc = "Environment variable passed to all plugins" },
330
391
{ .name = "options-for", .key = 'o',
331
392
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
332
393
.doc = "Options passed only to specified plugin" },
333
{ .name = "envs-for", .key = 'f',
394
{ .name = "env-for", .key = 'E',
334
395
.arg = "PLUGIN:ENV=value",
335
396
.doc = "Environment variable passed to specified plugin" },
336
397
{ .name = "disable", .key = 'd',
337
398
.arg = "PLUGIN",
338
399
.doc = "Disable a specific plugin", .group = 1 },
400
{ .name = "enable", .key = 'e',
401
.arg = "PLUGIN",
402
.doc = "Enable a specific plugin", .group = 1 },
339
403
{ .name = "plugin-dir", .key = 128,
340
404
.arg = "DIRECTORY",
341
405
.doc = "Specify a different plugin directory", .group = 2 },
342
{ .name = "userid", .key = 129,
343
.arg = "ID", .flags = 0,
344
.doc = "User ID the plugins will run as", .group = 2 },
345
{ .name = "groupid", .key = 130,
346
.arg = "ID", .flags = 0,
347
.doc = "Group ID the plugins will run as", .group = 2 },
348
{ .name = "debug", .key = 131,
349
.doc = "Debug mode", .group = 3 },
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 },
350
426
{ .name = NULL }
351
427
};
352
428
353
error_t parse_opt (int key, char *arg, struct argp_state *state) {
354
/* Get the INPUT argument from `argp_parse', which we know is a
355
pointer to our plugin list pointer. */
356
plugin **plugins = state->input;
357
switch (key) {
358
case 'g':
359
if (arg != NULL){
360
char *p;
361
while((p = strsep(&arg, ",")) != NULL){
362
if(p[0] == '\0'){
363
continue;
364
}
365
if(not add_argument(getplugin(NULL, plugins), p)){
366
perror("add_argument");
367
return ARGP_ERR_UNKNOWN;
368
}
369
}
370
}
371
break;
372
case 'e':
373
if(arg == NULL){
374
break;
375
}
376
{
377
char *envdef = strdup(arg);
378
if(envdef == NULL){
379
break;
380
}
381
if(not add_environment(getplugin(NULL, plugins), envdef)){
382
perror("add_environment");
383
}
384
}
385
break;
386
case 'o':
387
if (arg != NULL){
388
char *p_name = strsep(&arg, ":");
389
if(p_name[0] == '\0'){
390
break;
391
}
392
char *opt = strsep(&arg, ":");
393
if(opt[0] == '\0'){
394
break;
395
}
396
if(opt != NULL){
397
char *p;
398
while((p = strsep(&opt, ",")) != NULL){
399
if(p[0] == '\0'){
400
continue;
401
}
402
if(not add_argument(getplugin(p_name, plugins), p)){
403
perror("add_argument");
404
return ARGP_ERR_UNKNOWN;
405
}
406
}
407
}
408
}
409
break;
410
case 'f':
411
if(arg == NULL){
412
break;
413
}
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 */
414
476
{
415
477
char *envdef = strchr(arg, ':');
416
478
if(envdef == NULL){
417
break;
418
}
419
char *p_name = strndup(arg, (size_t) (envdef-arg));
420
if(p_name == NULL){
421
break;
422
}
479
argp_error(state, "No colon in \"%s\"", arg);
480
errno = EINVAL;
481
break;
482
}
483
*envdef = '\0';
423
484
envdef++;
424
if(not add_environment(getplugin(p_name, plugins), envdef)){
425
perror("add_environment");
426
}
427
}
428
break;
429
case 'd':
430
if (arg != NULL){
431
plugin *p = getplugin(arg, plugins);
432
if(p == NULL){
433
return ARGP_ERR_UNKNOWN;
434
}
435
p->disabled = true;
436
}
437
break;
438
case 128:
439
plugindir = arg;
440
break;
441
case 129:
442
uid = (uid_t)strtol(arg, NULL, 10);
443
break;
444
case 130:
445
gid = (gid_t)strtol(arg, NULL, 10);
446
break;
447
case 131:
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 */
448
546
debug = true;
449
547
break;
450
case ARGP_KEY_ARG:
451
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
452
break;
453
case ARGP_KEY_END:
454
break;
455
default:
456
return ARGP_ERR_UNKNOWN;
457
}
458
return 0;
459
}
460
461
plugin *plugin_list = NULL;
462
463
struct argp argp = { .options = options, .parser = parse_opt,
464
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
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 = "",
465
618
.doc = "Mandos plugin runner -- Run plugins" };
466
619
467
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
468
if (ret == ARGP_ERR_UNKNOWN){
469
fprintf(stderr, "Unknown error while parsing arguments\n");
470
exitstatus = EXIT_FAILURE;
471
goto fallback;
472
}
473
474
conffp = fopen(argfile, "r");
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
}
475
648
if(conffp != NULL){
476
649
char *org_line = NULL;
477
650
char *p, *arg, *new_arg, *line;
478
651
size_t size = 0;
479
ssize_t sret;
480
652
const char whitespace_delims[] = " \r\t\f\v\n";
481
653
const char comment_delim[] = "#";
482
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 */
483
667
while(true){
484
668
sret = getline(&org_line, &size, conffp);
485
669
if(sret == -1){
486
670
break;
487
671
}
488
672
489
673
line = org_line;
490
674
arg = strsep(&line, comment_delim);
491
675
while((p = strsep(&arg, whitespace_delims)) != NULL){
493
677
continue;
494
678
}
495
679
new_arg = strdup(p);
496
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
497
if (custom_argv == NULL){
498
perror("add_to_argv");
499
exitstatus = EXIT_FAILURE;
680
if(new_arg == NULL){
681
error(0, errno, "strdup");
682
exitstatus = EX_OSERR;
683
free(org_line);
500
684
goto fallback;
501
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;
502
704
}
503
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
}
504
714
free(org_line);
505
} else{
715
} else {
506
716
/* Check for harmful errors and go to fallback. Other errors might
507
717
not affect opening plugins */
508
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
509
perror("fopen");
510
exitstatus = EXIT_FAILURE;
718
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
719
error(0, errno, "fopen");
720
exitstatus = EX_OSERR;
511
721
goto fallback;
512
722
}
513
723
}
514
724
/* If there were any arguments from the configuration file, pass
725
them to parser as command line arguments */
515
726
if(custom_argv != NULL){
516
custom_argv[0] = argv[0];
517
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0,
518
&plugin_list);
519
if (ret == ARGP_ERR_UNKNOWN){
520
fprintf(stderr, "Unknown error while parsing arguments\n");
521
exitstatus = EXIT_FAILURE;
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;
522
741
goto fallback;
523
742
}
524
743
}
525
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
526
764
if(debug){
527
765
for(plugin *p = plugin_list; p != NULL; p=p->next){
528
766
fprintf(stderr, "Plugin: %s has %d arguments\n",
530
768
for(char **a = p->argv; *a != NULL; a++){
531
769
fprintf(stderr, "\tArg: %s\n", *a);
532
770
}
533
fprintf(stderr, "...and %u environment variables\n", p->envc);
771
fprintf(stderr, "...and %d environment variables\n", p->envc);
534
772
for(char **a = p->environ; *a != NULL; a++){
535
773
fprintf(stderr, "\t%s\n", *a);
536
774
}
537
775
}
538
776
}
539
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
}
540
807
ret = setuid(uid);
541
if (ret == -1){
542
perror("setuid");
543
}
544
545
setgid(gid);
546
if (ret == -1){
547
perror("setgid");
548
}
549
550
dir = opendir(plugindir);
551
if(dir == NULL){
552
perror("Could not open plugin dir");
553
exitstatus = EXIT_FAILURE;
554
goto fallback;
555
}
556
557
/* Set the FD_CLOEXEC flag on the directory, if possible */
808
if(ret == -1){
809
error(0, errno, "setuid");
810
}
811
812
/* Open plugin directory with close_on_exec flag */
558
813
{
559
int dir_fd = dirfd(dir);
560
if(dir_fd >= 0){
561
ret = set_cloexec_flag(dir_fd);
562
if(ret < 0){
563
perror("set_cloexec_flag");
564
exitstatus = EXIT_FAILURE;
565
goto fallback;
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;
566
858
}
567
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;
568
880
}
569
881
570
882
FD_ZERO(&rfds_all);
571
883
572
while(true){
573
dirst = readdir(dir);
574
575
// All directory entries have been processed
576
if(dirst == NULL){
577
if (errno == EBADF){
578
perror("readdir");
579
exitstatus = EXIT_FAILURE;
580
goto fallback;
581
}
582
break;
583
}
584
585
d_name_len = strlen(dirst->d_name);
586
587
// Ignore dotfiles, backup files and other junk
588
{
589
bool bad_name = false;
590
591
const char const *bad_prefixes[] = { ".", "#", NULL };
592
593
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
594
".dpkg-old",
595
".dpkg-divert", NULL };
596
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
597
size_t pre_len = strlen(*pre);
598
if((d_name_len >= pre_len)
599
and strncmp((dirst->d_name), *pre, pre_len) == 0){
600
if(debug){
601
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
602
" with bad prefix %s\n", dirst->d_name, *pre);
603
}
604
bad_name = true;
605
break;
606
}
607
}
608
609
if(bad_name){
610
continue;
611
}
612
613
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
614
size_t suf_len = strlen(*suf);
615
if((d_name_len >= suf_len)
616
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
617
== 0)){
618
if(debug){
619
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
620
" with bad suffix %s\n", dirst->d_name, *suf);
621
}
622
bad_name = true;
623
break;
624
}
625
}
626
627
if(bad_name){
628
continue;
629
}
630
}
631
632
char *filename;
633
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
634
if(ret < 0){
635
perror("asprintf");
636
continue;
637
}
638
639
ret = stat(filename, &st);
640
if (ret == -1){
641
perror("stat");
642
free(filename);
643
continue;
644
}
645
646
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)){
647
905
if(debug){
648
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
649
" 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);
650
910
}
651
free(filename);
911
TEMP_FAILURE_RETRY(close(plugin_fd));
912
free(direntries[i]);
652
913
continue;
653
914
}
654
plugin *p = getplugin(dirst->d_name, &plugin_list);
915
916
plugin *p = getplugin(direntries[i]->d_name);
655
917
if(p == NULL){
656
perror("getplugin");
657
free(filename);
918
error(0, errno, "getplugin");
919
TEMP_FAILURE_RETRY(close(plugin_fd));
920
free(direntries[i]);
658
921
continue;
659
922
}
660
923
if(p->disabled){
661
924
if(debug){
662
925
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
663
dirst->d_name);
926
direntries[i]->d_name);
664
927
}
665
free(filename);
928
TEMP_FAILURE_RETRY(close(plugin_fd));
929
free(direntries[i]);
666
930
continue;
667
931
}
668
932
{
669
933
/* Add global arguments to argument list for this plugin */
670
plugin *g = getplugin(NULL, &plugin_list);
934
plugin *g = getplugin(NULL);
671
935
if(g != NULL){
672
936
for(char **a = g->argv + 1; *a != NULL; a++){
673
937
if(not add_argument(p, *a)){
674
perror("add_argument");
938
error(0, errno, "add_argument");
675
939
}
676
940
}
677
941
/* Add global environment variables */
678
942
for(char **e = g->environ; *e != NULL; e++){
679
if(not add_environment(p, *e)){
680
perror("add_environment");
943
if(not add_environment(p, *e, false)){
944
error(0, errno, "add_environment");
681
945
}
682
946
}
683
947
}
684
948
}
685
/* If this plugin has any environment variables, we will call
686
using execve and need to duplicate the environment from this
687
process, too. */
949
/* If this plugin has any environment variables, we need to
950
duplicate the environment from this process, too. */
688
951
if(p->environ[0] != NULL){
689
952
for(char **e = environ; *e != NULL; e++){
690
char *copy = strdup(*e);
691
if(copy == NULL){
692
perror("strdup");
693
continue;
694
}
695
if(not add_environment(p, copy)){
696
perror("add_environment");
953
if(not add_environment(p, *e, false)){
954
error(0, errno, "add_environment");
697
955
}
698
956
}
699
957
}
700
958
701
959
int pipefd[2];
702
ret = pipe(pipefd);
703
if (ret == -1){
704
perror("pipe");
705
exitstatus = EXIT_FAILURE;
706
goto fallback;
707
}
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 */
708
982
ret = set_cloexec_flag(pipefd[0]);
709
983
if(ret < 0){
710
perror("set_cloexec_flag");
711
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]);
712
989
goto fallback;
713
990
}
714
991
ret = set_cloexec_flag(pipefd[1]);
715
992
if(ret < 0){
716
perror("set_cloexec_flag");
717
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]);
718
998
goto fallback;
719
999
}
1000
#endif /* not O_CLOEXEC */
720
1001
/* Block SIGCHLD until process is safely in process list */
721
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));
722
1005
if(ret < 0){
723
perror("sigprocmask");
724
exitstatus = EXIT_FAILURE;
1006
error(0, errno, "sigprocmask");
1007
exitstatus = EX_OSERR;
1008
free(direntries[i]);
725
1009
goto fallback;
726
1010
}
727
// Starting a new process to be watched
728
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);
729
1016
if(pid == -1){
730
perror("fork");
731
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]);
732
1024
goto fallback;
733
1025
}
734
1026
if(pid == 0){
735
1027
/* this is the child process */
736
1028
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
737
1029
if(ret < 0){
738
perror("sigaction");
739
_exit(EXIT_FAILURE);
1030
error(0, errno, "sigaction");
1031
_exit(EX_OSERR);
740
1032
}
741
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1033
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
742
1034
if(ret < 0){
743
perror("sigprocmask");
744
_exit(EXIT_FAILURE);
1035
error(0, errno, "sigprocmask");
1036
_exit(EX_OSERR);
745
1037
}
746
1038
747
1039
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
748
1040
if(ret == -1){
749
perror("dup2");
750
_exit(EXIT_FAILURE);
1041
error(0, errno, "dup2");
1042
_exit(EX_OSERR);
751
1043
}
752
1044
753
if(dirfd(dir) < 0){
754
/* If dir has no file descriptor, we could not set FD_CLOEXEC
755
above and must now close it manually here. */
756
closedir(dir);
757
}
758
if(p->environ[0] == NULL){
759
if(execv(filename, p->argv) < 0){
760
perror("execv");
761
_exit(EXIT_FAILURE);
762
}
763
} else {
764
if(execve(filename, p->argv, p->environ) < 0){
765
perror("execve");
766
_exit(EXIT_FAILURE);
767
}
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);
768
1051
}
769
1052
/* no return */
770
1053
}
771
/* parent process */
772
free(filename);
773
close(pipefd[1]); /* close unused write end of pipe */
774
process *new_process = malloc(sizeof(process));
775
if (new_process == NULL){
776
perror("malloc");
777
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
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)));
778
1064
if(ret < 0){
779
perror("sigprocmask");
1065
error(0, errno, "sigprocmask");
780
1066
}
781
exitstatus = EXIT_FAILURE;
1067
exitstatus = EX_OSERR;
1068
free(direntries[i]);
782
1069
goto fallback;
783
1070
}
784
785
*new_process = (struct process){ .pid = pid,
786
.fd = pipefd[0],
787
.next = process_list };
788
// List handling
789
process_list = new_process;
1071
free(direntries[i]);
1072
1073
new_plugin->pid = pid;
1074
new_plugin->fd = pipefd[0];
1075
790
1076
/* Unblock SIGCHLD so signal handler can be run if this process
791
1077
has already completed */
792
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));
793
1081
if(ret < 0){
794
perror("sigprocmask");
795
exitstatus = EXIT_FAILURE;
1082
error(0, errno, "sigprocmask");
1083
exitstatus = EX_OSERR;
796
1084
goto fallback;
797
1085
}
798
1086
799
FD_SET(new_process->fd, &rfds_all);
800
801
if (maxfd < new_process->fd){
802
maxfd = new_process->fd;
803
}
804
805
}
806
807
free_plugin_list(plugin_list);
808
plugin_list = NULL;
809
810
closedir(dir);
811
dir = NULL;
812
813
if (process_list == NULL){
814
fprintf(stderr, "No plugin processes started. Incorrect plugin"
815
" directory?\n");
816
process_list = NULL;
817
}
818
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){
819
1126
fd_set rfds = rfds_all;
820
1127
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
821
if (select_ret == -1){
822
perror("select");
823
exitstatus = EXIT_FAILURE;
1128
if(select_ret == -1 and errno != EINTR){
1129
error(0, errno, "select");
1130
exitstatus = EX_OSERR;
824
1131
goto fallback;
825
1132
}
826
1133
/* OK, now either a process completed, or something can be read
827
1134
from one of them */
828
for(process *proc = process_list; proc ; proc = proc->next){
1135
for(plugin *proc = plugin_list; proc != NULL;){
829
1136
/* Is this process completely done? */
830
if(proc->eof and proc->completed){
1137
if(proc->completed and proc->eof){
831
1138
/* Only accept the plugin output if it exited cleanly */
832
1139
if(not WIFEXITED(proc->status)
833
1140
or WEXITSTATUS(proc->status) != 0){
834
1141
/* Bad exit by plugin */
1142
835
1143
if(debug){
836
1144
if(WIFEXITED(proc->status)){
837
fprintf(stderr, "Plugin %u exited with status %d\n",
838
(unsigned int) (proc->pid),
1145
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1146
" status %d\n", proc->name,
1147
(intmax_t) (proc->pid),
839
1148
WEXITSTATUS(proc->status));
840
} else if(WIFSIGNALED(proc->status)) {
841
fprintf(stderr, "Plugin %u killed by signal %d\n",
842
(unsigned int) (proc->pid),
843
WTERMSIG(proc->status));
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)));
844
1155
} else if(WCOREDUMP(proc->status)){
845
fprintf(stderr, "Plugin %d dumped core\n",
846
(unsigned int) (proc->pid));
1156
fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1157
" core\n", proc->name, (intmax_t) (proc->pid));
847
1158
}
848
1159
}
1160
849
1161
/* Remove the plugin */
850
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
851
1177
/* Block signal while modifying process_list */
852
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));
853
1182
if(ret < 0){
854
perror("sigprocmask");
855
exitstatus = EXIT_FAILURE;
1183
error(0, errno, "sigprocmask");
1184
exitstatus = EX_OSERR;
856
1185
goto fallback;
857
1186
}
858
/* Delete this process entry from the list */
859
if(process_list == proc){
860
/* First one - simple */
861
process_list = proc->next;
862
} else {
863
/* Second one or later */
864
for(process *p = process_list; p != NULL; p = p->next){
865
if(p->next == proc){
866
p->next = proc->next;
867
break;
868
}
869
}
870
}
1187
1188
plugin *next_plugin = proc->next;
1189
free_plugin(proc);
1190
proc = next_plugin;
1191
871
1192
/* We are done modifying process list, so unblock signal */
872
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
873
NULL);
1193
ret = (int)(TEMP_FAILURE_RETRY
1194
(sigprocmask(SIG_UNBLOCK,
1195
&sigchld_action.sa_mask, NULL)));
874
1196
if(ret < 0){
875
perror("sigprocmask");
876
}
877
free(proc->buffer);
878
free(proc);
879
/* We deleted this process from the list, so we can't go
880
proc->next. Therefore, start over from the beginning of
881
the process list */
882
break;
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;
883
1207
}
1208
884
1209
/* This process exited nicely, so print its buffer */
885
1210
886
1211
bool bret = print_out_password(proc->buffer,
887
1212
proc->buffer_length);
888
1213
if(not bret){
889
perror("print_out_password");
890
exitstatus = EXIT_FAILURE;
1214
error(0, errno, "print_out_password");
1215
exitstatus = EX_IOERR;
891
1216
}
892
1217
goto fallback;
893
1218
}
1219
894
1220
/* This process has not completed. Does it have any output? */
895
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
896
1238
/* This process had nothing to say at this time */
1239
proc = proc->next;
897
1240
continue;
898
1241
}
899
1242
/* Before reading, make the process' data buffer large enough */
900
1243
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
901
proc->buffer = realloc(proc->buffer, proc->buffer_size
902
+ (size_t) BUFFER_SIZE);
903
if (proc->buffer == NULL){
904
perror("malloc");
905
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;
906
1249
goto fallback;
907
1250
}
1251
proc->buffer = new_buffer;
908
1252
proc->buffer_size += BUFFER_SIZE;
909
1253
}
910
1254
/* Read from the process */
911
ret = read(proc->fd, proc->buffer + proc->buffer_length,
912
BUFFER_SIZE);
913
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){
914
1260
/* Read error from this process; ignore the error */
1261
proc = proc->next;
915
1262
continue;
916
1263
}
917
if(ret == 0){
1264
if(sret == 0){
918
1265
/* got EOF */
919
1266
proc->eof = true;
920
1267
} else {
921
proc->buffer_length += (size_t) ret;
1268
proc->buffer_length += (size_t) sret;
922
1269
}
923
1270
}
924
1271
}
925
926
1272
1273
927
1274
fallback:
928
1275
929
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
1276
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1277
and exitstatus != EX_OK)){
930
1278
/* Fallback if all plugins failed, none are found or an error
931
1279
occured */
932
1280
bool bret;
933
1281
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
934
1282
char *passwordbuffer = getpass("Password: ");
935
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);
936
1290
if(not bret){
937
perror("print_out_password");
938
exitstatus = EXIT_FAILURE;
1291
error(0, errno, "print_out_password");
1292
exitstatus = EX_IOERR;
939
1293
}
940
1294
}
941
1295
942
1296
/* Restore old signal handler */
943
1297
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
944
1298
if(ret == -1){
945
perror("sigaction");
946
exitstatus = EXIT_FAILURE;
1299
error(0, errno, "sigaction");
1300
exitstatus = EX_OSERR;
947
1301
}
948
1302
949
1303
if(custom_argv != NULL){
950
for(char **arg = custom_argv; *arg != NULL; arg++){
1304
for(char **arg = custom_argv+1; *arg != NULL; arg++){
951
1305
free(*arg);
952
1306
}
953
1307
free(custom_argv);
954
1308
}
955
free_plugin_list(plugin_list);
956
957
if(dir != NULL){
958
closedir(dir);
1309
1310
free(direntries);
1311
1312
if(dir_fd != -1){
1313
TEMP_FAILURE_RETRY(close(dir_fd));
959
1314
}
960
1315
961
/* Free the process list and kill the processes */
962
for(process *next; process_list != NULL; process_list = next){
963
next = process_list->next;
964
close(process_list->fd);
965
ret = kill(process_list->pid, SIGTERM);
966
if(ret == -1 and errno != ESRCH){
967
/* set-uid proccesses migth not get closed */
968
perror("kill");
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
}
969
1325
}
970
free(process_list->buffer);
971
free(process_list);
972
1326
}
973
1327
974
1328
/* Wait for any remaining child processes to terminate */
975
do{
1329
do {
976
1330
ret = wait(NULL);
977
1331
} while(ret >= 0);
978
1332
if(errno != ECHILD){
979
perror("wait");
1333
error(0, errno, "wait");
980
1334
}
981
1335
1336
free_plugin_list();
1337
1338
free(plugindir);
1339
free(argfile);
1340
982
1341
return exitstatus;
983
1342
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0