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