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