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