To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« 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:
- .bzrignore
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/password-request.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 -*- */
2
/*
3
* Mandos plugin runner - Run Mandos plugins
4
*
5
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
*
7
* This program is free software: you can redistribute it and/or
8
* modify it under the terms of the GNU General Public License as
9
* published by the Free Software Foundation, either version 3 of the
10
* License, or (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful, but
13
* WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program. If not, see
19
* <http://www.gnu.org/licenses/>.
20
*
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
*/
23
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
26
#include <stddef.h> /* size_t, NULL */
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
EXIT_SUCCESS, realloc() */
29
#include <stdbool.h> /* bool, true, false */
30
#include <stdio.h> /* perror, popen(), fileno(),
31
fprintf(), stderr, STDOUT_FILENO */
32
#include <sys/types.h> /* DIR, opendir(), stat(), struct
33
stat, waitpid(), WIFEXITED(),
34
WEXITSTATUS(), wait(), pid_t,
35
uid_t, gid_t, getuid(), getgid(),
36
dirfd() */
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() */
41
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
42
#include <iso646.h> /* and, or, not */
43
#include <dirent.h> /* DIR, struct dirent, opendir(),
44
readdir(), closedir(), dirfd() */
45
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
46
fcntl(), setuid(), setgid(),
47
F_GETFD, F_SETFD, FD_CLOEXEC,
48
access(), pipe(), fork(), close()
49
dup2, STDOUT_FILENO, _exit(),
50
execv(), write(), read(),
51
close() */
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), asprintf() */
55
#include <errno.h> /* errno */
56
#include <argp.h> /* struct argp_option, struct
57
argp_state, struct argp,
58
argp_parse(), ARGP_ERR_UNKNOWN,
59
ARGP_KEY_END, ARGP_KEY_ARG,
60
error_t */
61
#include <signal.h> /* struct sigaction, sigemptyset(),
62
sigaddset(), sigaction(),
63
sigprocmask(), SIG_BLOCK, SIGCHLD,
64
SIG_UNBLOCK, kill() */
65
#include <errno.h> /* errno, EBADF */
66
67
#define BUFFER_SIZE 256
68
69
#define PDIR "/lib/mandos/plugins.d"
70
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
71
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;
76
77
typedef struct plugin{
78
char *name; /* can be NULL or any plugin name */
79
char **argv;
80
int argc;
81
char **environ;
82
int envc;
83
bool disabled;
84
85
/* 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{
86
19
pid_t pid;
87
20
int fd;
88
21
char *buffer;
89
size_t buffer_size;
90
size_t buffer_length;
91
bool eof;
92
volatile bool completed;
93
volatile int status;
94
struct plugin *next;
95
} plugin;
96
97
static plugin *plugin_list = NULL;
98
99
/* Gets a existing plugin based on name,
100
or if none is found, creates a new one */
101
static plugin *getplugin(char *name){
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))){
106
return p;
107
}
108
}
109
/* Create a new plugin */
110
plugin *new_plugin = malloc(sizeof(plugin));
111
if (new_plugin == NULL){
112
return NULL;
113
}
114
char *copy_name = NULL;
115
if(name != NULL){
116
copy_name = strdup(name);
117
if(copy_name == NULL){
118
return NULL;
119
}
120
}
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){
129
free(copy_name);
130
free(new_plugin);
131
return NULL;
132
}
133
new_plugin->argv[0] = copy_name;
134
new_plugin->argv[1] = NULL;
135
136
new_plugin->environ = malloc(sizeof(char *));
137
if(new_plugin->environ == NULL){
138
free(copy_name);
139
free(new_plugin->argv);
140
free(new_plugin);
141
return NULL;
142
}
143
new_plugin->environ[0] = NULL;
144
145
/* Append the new plugin to the list */
146
plugin_list = new_plugin;
147
return new_plugin;
148
}
149
150
/* Helper function for add_argument and add_environment */
151
static bool add_to_char_array(const char *new, char ***array,
152
int *len){
153
/* Resize the pointed-to array to hold one more pointer */
154
*array = realloc(*array, sizeof(char *)
155
* (size_t) ((*len) + 2));
156
/* Malloc check */
157
if(*array == NULL){
158
return false;
159
}
160
/* Make a copy of the new string */
161
char *copy = strdup(new);
162
if(copy == NULL){
163
return false;
164
}
165
/* Insert the copy */
166
(*array)[*len] = copy;
167
(*len)++;
168
/* Add a new terminating NULL pointer to the last element */
169
(*array)[*len] = NULL;
170
return true;
171
}
172
173
/* Add to a plugin's argument vector */
174
static bool add_argument(plugin *p, const char *arg){
175
if(p == NULL){
176
return false;
177
}
178
return add_to_char_array(arg, &(p->argv), &(p->argc));
179
}
180
181
/* Add to a plugin's environment */
182
static bool add_environment(plugin *p, const char *def, bool replace){
183
if(p == NULL){
184
return false;
185
}
186
/* namelen = length of name of environment variable */
187
size_t namelen = (size_t)(strchrnul(def, '=') - def);
188
/* Search for this environment variable */
189
for(char **e = p->environ; *e != NULL; e++){
190
if(strncmp(*e, def, namelen+1) == 0){
191
/* It already exists */
192
if(replace){
193
char *new = realloc(*e, strlen(def));
194
if(new == NULL){
195
return false;
196
}
197
*e = new;
198
strcpy(*e, def);
199
}
200
return true;
201
}
202
}
203
return add_to_char_array(def, &(p->environ), &(p->envc));
204
}
205
206
/*
207
* Based on the example in the GNU LibC manual chapter 13.13 "File
208
* Descriptor Flags".
209
* *Note File Descriptor Flags:(libc)Descriptor Flags.
210
*/
211
static int set_cloexec_flag(int fd)
212
{
213
int ret = fcntl(fd, F_GETFD, 0);
214
/* If reading the flags failed, return error indication now. */
215
if(ret < 0){
216
return ret;
217
}
218
/* Store modified flag word in the descriptor. */
219
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
220
}
221
222
223
/* Mark processes as completed when they exit, and save their exit
224
status. */
225
void handle_sigchld(__attribute__((unused)) int sig){
226
while(true){
227
plugin *proc = plugin_list;
228
int status;
229
pid_t pid = waitpid(-1, &status, WNOHANG);
230
if(pid == 0){
231
/* Only still running child processes */
232
break;
233
}
234
if(pid == -1){
235
if (errno != ECHILD){
236
perror("waitpid");
237
}
238
/* No child processes */
239
break;
240
}
241
242
/* A child exited, find it in process_list */
243
while(proc != NULL and proc->pid != pid){
244
proc = proc->next;
245
}
246
if(proc == NULL){
247
/* Process not found in process list */
248
continue;
249
}
250
proc->status = status;
251
proc->completed = true;
252
}
253
}
254
255
/* Prints out a password to stdout */
256
bool print_out_password(const char *buffer, size_t length){
257
ssize_t ret;
258
if(length>0 and buffer[length-1] == '\n'){
259
length--;
260
}
261
for(size_t written = 0; written < length; written += (size_t)ret){
262
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
263
length - written));
264
if(ret < 0){
265
return false;
266
}
267
}
268
return true;
269
}
270
271
/* Removes and free a plugin from the plugin list */
272
static void free_plugin(plugin *plugin_node){
273
274
for(char **arg = plugin_node->argv; *arg != NULL; arg++){
275
free(*arg);
276
}
277
free(plugin_node->argv);
278
for(char **env = plugin_node->environ; *env != NULL; env++){
279
free(*env);
280
}
281
free(plugin_node->environ);
282
free(plugin_node->buffer);
283
284
/* Removes the plugin from the singly-linked list */
285
if(plugin_node == plugin_list){
286
/* First one - simple */
287
plugin_list = plugin_list->next;
288
} else {
289
/* Second one or later */
290
for(plugin *p = plugin_list; p != NULL; p = p->next){
291
if(p->next == plugin_node){
292
p->next = plugin_node->next;
293
break;
294
}
295
}
296
}
297
298
free(plugin_node);
299
}
300
301
static void free_plugin_list(void){
302
while(plugin_list != NULL){
303
free_plugin(plugin_list);
304
}
305
}
22
int buffer_size;
23
int buffer_length;
24
struct process *next;
25
} process;
26
27
#define BUFFER_SIZE 256
306
28
307
29
int main(int argc, char *argv[]){
308
char *plugindir = NULL;
309
char *argfile = NULL;
310
FILE *conffp;
311
size_t d_name_len;
312
DIR *dir = NULL;
30
char plugindir[] = "plugins.d";
31
size_t d_name_len, plugindir_len = sizeof(plugindir)-1;
32
DIR *dir;
313
33
struct dirent *dirst;
314
34
struct stat st;
315
fd_set rfds_all;
35
fd_set rfds_orig;
316
36
int ret, maxfd = 0;
317
uid_t uid = 65534;
318
gid_t gid = 65534;
319
bool debug = false;
320
int exitstatus = EXIT_SUCCESS;
321
struct sigaction old_sigchld_action;
322
struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
323
.sa_flags = SA_NOCLDSTOP };
324
char **custom_argv = NULL;
325
int custom_argc = 0;
326
327
/* Establish a signal handler */
328
sigemptyset(&sigchld_action.sa_mask);
329
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
330
if(ret == -1){
331
perror("sigaddset");
332
exitstatus = EXIT_FAILURE;
333
goto fallback;
334
}
335
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
336
if(ret == -1){
337
perror("sigaction");
338
exitstatus = EXIT_FAILURE;
339
goto fallback;
340
}
341
342
/* The options we understand. */
343
struct argp_option options[] = {
344
{ .name = "global-options", .key = 'g',
345
.arg = "OPTION[,OPTION[,...]]",
346
.doc = "Options passed to all plugins" },
347
{ .name = "global-env", .key = 'e',
348
.arg = "VAR=value",
349
.doc = "Environment variable passed to all plugins" },
350
{ .name = "options-for", .key = 'o',
351
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
352
.doc = "Options passed only to specified plugin" },
353
{ .name = "env-for", .key = 'f',
354
.arg = "PLUGIN:ENV=value",
355
.doc = "Environment variable passed to specified plugin" },
356
{ .name = "disable", .key = 'd',
357
.arg = "PLUGIN",
358
.doc = "Disable a specific plugin", .group = 1 },
359
{ .name = "plugin-dir", .key = 128,
360
.arg = "DIRECTORY",
361
.doc = "Specify a different plugin directory", .group = 2 },
362
{ .name = "config-file", .key = 129,
363
.arg = "FILE",
364
.doc = "Specify a different configuration file", .group = 2 },
365
{ .name = "userid", .key = 130,
366
.arg = "ID", .flags = 0,
367
.doc = "User ID the plugins will run as", .group = 3 },
368
{ .name = "groupid", .key = 131,
369
.arg = "ID", .flags = 0,
370
.doc = "Group ID the plugins will run as", .group = 3 },
371
{ .name = "debug", .key = 132,
372
.doc = "Debug mode", .group = 4 },
373
{ .name = NULL }
374
};
375
376
error_t parse_opt (int key, char *arg, __attribute__((unused))
377
struct argp_state *state) {
378
/* Get the INPUT argument from `argp_parse', which we know is a
379
pointer to our plugin list pointer. */
380
switch (key) {
381
case 'g': /* --global-options */
382
if (arg != NULL){
383
char *p;
384
while((p = strsep(&arg, ",")) != NULL){
385
if(p[0] == '\0'){
386
continue;
387
}
388
if(not add_argument(getplugin(NULL), p)){
389
perror("add_argument");
390
return ARGP_ERR_UNKNOWN;
391
}
392
}
393
}
394
break;
395
case 'e': /* --global-env */
396
if(arg == NULL){
397
break;
398
}
399
{
400
char *envdef = strdup(arg);
401
if(envdef == NULL){
402
break;
403
}
404
if(not add_environment(getplugin(NULL), envdef, true)){
405
perror("add_environment");
406
}
407
}
408
break;
409
case 'o': /* --options-for */
410
if (arg != NULL){
411
char *p_name = strsep(&arg, ":");
412
if(p_name[0] == '\0'){
413
break;
414
}
415
char *opt = strsep(&arg, ":");
416
if(opt[0] == '\0'){
417
break;
418
}
419
if(opt != NULL){
420
char *p;
421
while((p = strsep(&opt, ",")) != NULL){
422
if(p[0] == '\0'){
423
continue;
424
}
425
if(not add_argument(getplugin(p_name), p)){
426
perror("add_argument");
427
return ARGP_ERR_UNKNOWN;
428
}
429
}
430
}
431
}
432
break;
433
case 'f': /* --env-for */
434
if(arg == NULL){
435
break;
436
}
437
{
438
char *envdef = strchr(arg, ':');
439
if(envdef == NULL){
440
break;
441
}
442
char *p_name = strndup(arg, (size_t) (envdef-arg));
443
if(p_name == NULL){
444
break;
445
}
446
envdef++;
447
if(not add_environment(getplugin(p_name), envdef, true)){
448
perror("add_environment");
449
}
450
}
451
break;
452
case 'd': /* --disable */
453
if (arg != NULL){
454
plugin *p = getplugin(arg);
455
if(p == NULL){
456
return ARGP_ERR_UNKNOWN;
457
}
458
p->disabled = true;
459
}
460
break;
461
case 128: /* --plugin-dir */
462
plugindir = strdup(arg);
463
if(plugindir == NULL){
464
perror("strdup");
465
}
466
break;
467
case 129: /* --config-file */
468
argfile = strdup(arg);
469
if(argfile == NULL){
470
perror("strdup");
471
}
472
break;
473
case 130: /* --userid */
474
uid = (uid_t)strtol(arg, NULL, 10);
475
break;
476
case 131: /* --groupid */
477
gid = (gid_t)strtol(arg, NULL, 10);
478
break;
479
case 132: /* --debug */
480
debug = true;
481
break;
482
case ARGP_KEY_ARG:
483
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
484
break;
485
case ARGP_KEY_END:
486
break;
487
default:
488
return ARGP_ERR_UNKNOWN;
489
}
490
return 0;
491
}
492
493
struct argp argp = { .options = options, .parser = parse_opt,
494
.args_doc = "",
495
.doc = "Mandos plugin runner -- Run plugins" };
496
497
/* Open the configfile if available */
498
if (argfile == NULL){
499
conffp = fopen(AFILE, "r");
500
} else {
501
conffp = fopen(argfile, "r");
502
}
503
if(conffp != NULL){
504
char *org_line = NULL;
505
char *p, *arg, *new_arg, *line;
506
size_t size = 0;
507
ssize_t sret;
508
const char whitespace_delims[] = " \r\t\f\v\n";
509
const char comment_delim[] = "#";
510
511
custom_argc = 1;
512
custom_argv = malloc(sizeof(char*) * 2);
513
if(custom_argv == NULL){
514
perror("malloc");
515
exitstatus = EXIT_FAILURE;
516
goto fallback;
517
}
518
custom_argv[0] = argv[0];
519
custom_argv[1] = NULL;
520
521
/* for each line in the config file, strip whitespace and ignore
522
commented text */
523
while(true){
524
sret = getline(&org_line, &size, conffp);
525
if(sret == -1){
526
break;
527
}
528
529
line = org_line;
530
arg = strsep(&line, comment_delim);
531
while((p = strsep(&arg, whitespace_delims)) != NULL){
532
if(p[0] == '\0'){
533
continue;
534
}
535
new_arg = strdup(p);
536
if(new_arg == NULL){
537
perror("strdup");
538
exitstatus = EXIT_FAILURE;
539
free(org_line);
540
goto fallback;
541
}
542
543
custom_argc += 1;
544
custom_argv = realloc(custom_argv, sizeof(char *)
545
* ((unsigned int) custom_argc + 1));
546
if(custom_argv == NULL){
547
perror("realloc");
548
exitstatus = EXIT_FAILURE;
549
free(org_line);
550
goto fallback;
551
}
552
custom_argv[custom_argc-1] = new_arg;
553
custom_argv[custom_argc] = NULL;
554
}
555
}
556
free(org_line);
557
} else {
558
/* Check for harmful errors and go to fallback. Other errors might
559
not affect opening plugins */
560
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
561
perror("fopen");
562
exitstatus = EXIT_FAILURE;
563
goto fallback;
564
}
565
}
566
/* If there was any arguments from configuration file,
567
pass them to parser as command arguments */
568
if(custom_argv != NULL){
569
ret = argp_parse (&argp, custom_argc, custom_argv, ARGP_IN_ORDER,
570
0, NULL);
571
if (ret == ARGP_ERR_UNKNOWN){
572
fprintf(stderr, "Unknown error while parsing arguments\n");
573
exitstatus = EXIT_FAILURE;
574
goto fallback;
575
}
576
}
577
578
/* Parse actual command line arguments, to let them override the
579
config file */
580
ret = argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, NULL);
581
if (ret == ARGP_ERR_UNKNOWN){
582
fprintf(stderr, "Unknown error while parsing arguments\n");
583
exitstatus = EXIT_FAILURE;
584
goto fallback;
585
}
586
587
if(debug){
588
for(plugin *p = plugin_list; p != NULL; p=p->next){
589
fprintf(stderr, "Plugin: %s has %d arguments\n",
590
p->name ? p->name : "Global", p->argc - 1);
591
for(char **a = p->argv; *a != NULL; a++){
592
fprintf(stderr, "\tArg: %s\n", *a);
593
}
594
fprintf(stderr, "...and %u environment variables\n", p->envc);
595
for(char **a = p->environ; *a != NULL; a++){
596
fprintf(stderr, "\t%s\n", *a);
597
}
598
}
599
}
600
601
/* Strip permissions down to nobody */
602
ret = setuid(uid);
603
if (ret == -1){
604
perror("setuid");
605
}
606
setgid(gid);
607
if (ret == -1){
608
perror("setgid");
609
}
610
611
if (plugindir == NULL){
612
dir = opendir(PDIR);
613
} else {
614
dir = opendir(plugindir);
615
}
616
37
process *process_list = NULL;
38
39
dir = opendir(plugindir);
40
617
41
if(dir == NULL){
618
perror("Could not open plugin dir");
619
exitstatus = EXIT_FAILURE;
620
goto fallback;
621
}
622
623
/* Set the FD_CLOEXEC flag on the directory, if possible */
624
{
625
int dir_fd = dirfd(dir);
626
if(dir_fd >= 0){
627
ret = set_cloexec_flag(dir_fd);
628
if(ret < 0){
629
perror("set_cloexec_flag");
630
exitstatus = EXIT_FAILURE;
631
goto fallback;
632
}
633
}
634
}
635
636
FD_ZERO(&rfds_all);
637
638
/* Read and execute any executable in the plugin directory*/
42
fprintf(stderr, "Can not open directory\n");
43
return EXIT_FAILURE;
44
}
45
46
FD_ZERO(&rfds_orig);
47
639
48
while(true){
640
49
dirst = readdir(dir);
641
50
642
/* All directory entries have been processed */
51
// All directory entries have been processed
643
52
if(dirst == NULL){
644
if (errno == EBADF){
645
perror("readdir");
646
exitstatus = EXIT_FAILURE;
647
goto fallback;
648
}
649
53
break;
650
54
}
651
55
652
56
d_name_len = strlen(dirst->d_name);
653
57
654
/* Ignore dotfiles, backup files and other junk */
655
{
656
bool bad_name = false;
657
658
const char const *bad_prefixes[] = { ".", "#", NULL };
659
660
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
661
".dpkg-old",
662
".dpkg-divert", NULL };
663
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
664
size_t pre_len = strlen(*pre);
665
if((d_name_len >= pre_len)
666
and strncmp((dirst->d_name), *pre, pre_len) == 0){
667
if(debug){
668
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
669
" with bad prefix %s\n", dirst->d_name, *pre);
670
}
671
bad_name = true;
672
break;
673
}
674
}
675
if(bad_name){
676
continue;
677
}
678
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
679
size_t suf_len = strlen(*suf);
680
if((d_name_len >= suf_len)
681
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
682
== 0)){
683
if(debug){
684
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
685
" with bad suffix %s\n", dirst->d_name, *suf);
686
}
687
bad_name = true;
688
break;
689
}
690
}
691
692
if(bad_name){
693
continue;
694
}
695
}
696
697
char *filename;
698
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
699
if(ret < 0){
700
perror("asprintf");
701
continue;
702
}
703
704
ret = stat(filename, &st);
705
if (ret == -1){
706
perror("stat");
707
free(filename);
708
continue;
709
}
710
711
/* Ignore non-executable files */
712
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
713
if(debug){
714
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
715
" with bad type or mode\n", filename);
716
}
717
free(filename);
718
continue;
719
}
720
721
plugin *p = getplugin(dirst->d_name);
722
if(p == NULL){
723
perror("getplugin");
724
free(filename);
725
continue;
726
}
727
if(p->disabled){
728
if(debug){
729
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
730
dirst->d_name);
731
}
732
free(filename);
733
continue;
734
}
735
{
736
/* Add global arguments to argument list for this plugin */
737
plugin *g = getplugin(NULL);
738
if(g != NULL){
739
for(char **a = g->argv + 1; *a != NULL; a++){
740
if(not add_argument(p, *a)){
741
perror("add_argument");
742
}
743
}
744
/* Add global environment variables */
745
for(char **e = g->environ; *e != NULL; e++){
746
if(not add_environment(p, *e, false)){
747
perror("add_environment");
748
}
749
}
750
}
751
}
752
/* If this plugin has any environment variables, we will call
753
using execve and need to duplicate the environment from this
754
process, too. */
755
if(p->environ[0] != NULL){
756
for(char **e = environ; *e != NULL; e++){
757
if(not add_environment(p, *e, false)){
758
perror("add_environment");
759
}
760
}
761
}
762
763
int pipefd[2];
764
ret = pipe(pipefd);
765
if (ret == -1){
766
perror("pipe");
767
exitstatus = EXIT_FAILURE;
768
goto fallback;
769
}
770
/* Ask OS to automatic close the pipe on exec */
771
ret = set_cloexec_flag(pipefd[0]);
772
if(ret < 0){
773
perror("set_cloexec_flag");
774
exitstatus = EXIT_FAILURE;
775
goto fallback;
776
}
777
ret = set_cloexec_flag(pipefd[1]);
778
if(ret < 0){
779
perror("set_cloexec_flag");
780
exitstatus = EXIT_FAILURE;
781
goto fallback;
782
}
783
/* Block SIGCHLD until process is safely in process list */
784
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
785
if(ret < 0){
786
perror("sigprocmask");
787
exitstatus = EXIT_FAILURE;
788
goto fallback;
789
}
790
/* Starting a new process to be watched */
791
pid_t pid = fork();
792
if(pid == -1){
793
perror("fork");
794
exitstatus = EXIT_FAILURE;
795
goto fallback;
796
}
797
if(pid == 0){
798
/* this is the child process */
799
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
800
if(ret < 0){
801
perror("sigaction");
802
_exit(EXIT_FAILURE);
803
}
804
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
805
if(ret < 0){
806
perror("sigprocmask");
807
_exit(EXIT_FAILURE);
808
}
809
810
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
811
if(ret == -1){
812
perror("dup2");
813
_exit(EXIT_FAILURE);
814
}
815
816
if(dirfd(dir) < 0){
817
/* If dir has no file descriptor, we could not set FD_CLOEXEC
818
above and must now close it manually here. */
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 */
819
79
closedir(dir);
820
}
821
if(p->environ[0] == NULL){
822
if(execv(filename, p->argv) < 0){
823
perror("execv");
824
_exit(EXIT_FAILURE);
825
}
826
} else {
827
if(execve(filename, p->argv, p->environ) < 0){
828
perror("execve");
829
_exit(EXIT_FAILURE);
830
}
831
}
832
/* no return */
833
}
834
/* Parent process */
835
close(pipefd[1]); /* Close unused write end of pipe */
836
free(filename);
837
plugin *new_plugin = getplugin(dirst->d_name);
838
if (new_plugin == NULL){
839
perror("getplugin");
840
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
841
if(ret < 0){
842
perror("sigprocmask");
843
}
844
exitstatus = EXIT_FAILURE;
845
goto fallback;
846
}
847
848
new_plugin->pid = pid;
849
new_plugin->fd = pipefd[0];
850
851
/* Unblock SIGCHLD so signal handler can be run if this process
852
has already completed */
853
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
854
if(ret < 0){
855
perror("sigprocmask");
856
exitstatus = EXIT_FAILURE;
857
goto fallback;
858
}
859
860
FD_SET(new_plugin->fd, &rfds_all);
861
862
if (maxfd < new_plugin->fd){
863
maxfd = new_plugin->fd;
864
}
865
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
}
866
115
}
867
116
868
117
closedir(dir);
869
dir = NULL;
870
871
for(plugin *p = plugin_list; p != NULL; p = p->next){
872
if(p->pid != 0){
118
119
if (process_list != NULL){
120
while(true){
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
}
873
178
break;
874
179
}
875
if(p->next == NULL){
876
fprintf(stderr, "No plugin processes started. Incorrect plugin"
877
" directory?\n");
878
free_plugin_list();
879
}
880
}
881
882
/* Main loop while running plugins exist */
883
while(plugin_list){
884
fd_set rfds = rfds_all;
885
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
886
if (select_ret == -1){
887
perror("select");
888
exitstatus = EXIT_FAILURE;
889
goto fallback;
890
}
891
/* OK, now either a process completed, or something can be read
892
from one of them */
893
for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
894
/* Is this process completely done? */
895
if(proc->eof and proc->completed){
896
/* Only accept the plugin output if it exited cleanly */
897
if(not WIFEXITED(proc->status)
898
or WEXITSTATUS(proc->status) != 0){
899
/* Bad exit by plugin */
900
901
if(debug){
902
if(WIFEXITED(proc->status)){
903
fprintf(stderr, "Plugin %u exited with status %d\n",
904
(unsigned int) (proc->pid),
905
WEXITSTATUS(proc->status));
906
} else if(WIFSIGNALED(proc->status)) {
907
fprintf(stderr, "Plugin %u killed by signal %d\n",
908
(unsigned int) (proc->pid),
909
WTERMSIG(proc->status));
910
} else if(WCOREDUMP(proc->status)){
911
fprintf(stderr, "Plugin %d dumped core\n",
912
(unsigned int) (proc->pid));
913
}
914
}
915
916
/* Remove the plugin */
917
FD_CLR(proc->fd, &rfds_all);
918
919
/* Block signal while modifying process_list */
920
ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
921
if(ret < 0){
922
perror("sigprocmask");
923
exitstatus = EXIT_FAILURE;
924
goto fallback;
925
}
926
free_plugin(proc);
927
/* We are done modifying process list, so unblock signal */
928
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
929
NULL);
930
if(ret < 0){
931
perror("sigprocmask");
932
exitstatus = EXIT_FAILURE;
933
goto fallback;
934
}
935
936
if(plugin_list == NULL){
937
break;
938
}
939
continue;
940
}
941
942
/* This process exited nicely, so print its buffer */
943
944
bool bret = print_out_password(proc->buffer,
945
proc->buffer_length);
946
if(not bret){
947
perror("print_out_password");
948
exitstatus = EXIT_FAILURE;
949
}
950
goto fallback;
951
}
952
953
/* This process has not completed. Does it have any output? */
954
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
955
/* This process had nothing to say at this time */
956
continue;
957
}
958
/* Before reading, make the process' data buffer large enough */
959
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
960
proc->buffer = realloc(proc->buffer, proc->buffer_size
961
+ (size_t) BUFFER_SIZE);
962
if (proc->buffer == NULL){
963
perror("malloc");
964
exitstatus = EXIT_FAILURE;
965
goto fallback;
966
}
967
proc->buffer_size += BUFFER_SIZE;
968
}
969
/* Read from the process */
970
ret = read(proc->fd, proc->buffer + proc->buffer_length,
971
BUFFER_SIZE);
972
if(ret < 0){
973
/* Read error from this process; ignore the error */
974
continue;
975
}
976
if(ret == 0){
977
/* got EOF */
978
proc->eof = true;
979
} else {
980
proc->buffer_length += (size_t) ret;
981
}
982
}
983
}
984
985
986
fallback:
987
988
if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){
989
/* Fallback if all plugins failed, none are found or an error
990
occured */
991
bool bret;
992
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
993
char *passwordbuffer = getpass("Password: ");
994
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
995
if(not bret){
996
perror("print_out_password");
997
exitstatus = EXIT_FAILURE;
998
}
999
}
1000
1001
/* Restore old signal handler */
1002
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1003
if(ret == -1){
1004
perror("sigaction");
1005
exitstatus = EXIT_FAILURE;
1006
}
1007
1008
if(custom_argv != NULL){
1009
for(char **arg = custom_argv+1; *arg != NULL; arg++){
1010
free(*arg);
1011
}
1012
free(custom_argv);
1013
}
1014
1015
if(dir != NULL){
1016
closedir(dir);
1017
}
1018
1019
/* Free the process list and kill the processes */
1020
for(plugin *p = plugin_list; p != NULL; p = p->next){
1021
if(p->pid != 0){
1022
close(p->fd);
1023
ret = kill(p->pid, SIGTERM);
1024
if(ret == -1 and errno != ESRCH){
1025
/* Set-uid proccesses might not get closed */
1026
perror("kill");
1027
}
1028
}
1029
}
1030
1031
/* Wait for any remaining child processes to terminate */
1032
do{
1033
ret = wait(NULL);
1034
} while(ret >= 0);
1035
if(errno != ECHILD){
1036
perror("wait");
1037
}
1038
1039
free_plugin_list();
1040
1041
free(plugindir);
1042
free(argfile);
1043
1044
return exitstatus;
180
}
181
return EXIT_SUCCESS;
1045
182
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0