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