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