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