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