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