To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-client.c
- browse files at revision 24.1.51
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.51
- Committer: Björn Påhlsson
- Date: 2008-08-15 20:17:32 UTC
- mto: (237.7.1 mandos) (24.1.154 mandos)
- mto: This revision was merged to the branch mainline in revision 77.
- Revision ID: belorn@braxen-20080815201732-b7uux3yqs05b3fy9
Added configuration files support for mandos-client
Removed plus argument support for mandos-client
Removed plus argument support for mandos-client
- files added:
- network-protocol.txt
- files removed:
- initramfs-tools-script
- files renamed:
- plugin-runner.c => mandos-client.c
- plugin-runner.xml => mandos-client.xml
- files modified:
- Makefile
added
removed
mandos-client.c
21
21
* Contact the authors at <mandos@fukt.bsnet.se>.
22
22
*/
23
23
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
25
26
26
#include <stddef.h> /* size_t, NULL */
27
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
28
EXIT_SUCCESS, realloc() */
51
51
close() */
52
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
53
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), asprintf() */
54
#include <string.h> /* strsep, strlen(), strcpy(),
55
strcat() */
55
56
#include <errno.h> /* errno */
56
57
#include <argp.h> /* struct argp_option, struct
57
58
argp_state, struct argp,
64
65
#include <errno.h> /* errno, EBADF */
65
66
66
67
#define BUFFER_SIZE 256
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
68
#define CONFFILE "/conf/conf.d/mandos/client.conf"
68
69
69
const char *argp_program_version = "plugin-runner 1.0";
70
const char *argp_program_version = "mandos-client 1.0";
70
71
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
71
72
72
73
struct process;
87
88
char *name; /* can be NULL or any plugin name */
88
89
char **argv;
89
90
int argc;
90
char **environ;
91
int envc;
92
91
bool disabled;
93
92
struct plugin *next;
94
93
} plugin;
103
102
/* Create a new plugin */
104
103
plugin *new_plugin = malloc(sizeof(plugin));
105
104
if (new_plugin == NULL){
106
return NULL;
107
}
108
char *copy_name = NULL;
109
if(name != NULL){
110
copy_name = strdup(name);
111
}
112
if(copy_name == NULL){
113
return NULL;
114
}
115
116
*new_plugin = (plugin) { .name = copy_name,
117
.argc = 1,
118
.envc = 0,
119
.disabled = false,
120
.next = *plugin_list };
121
105
perror("malloc");
106
exit(EXIT_FAILURE);
107
}
108
new_plugin->name = name;
122
109
new_plugin->argv = malloc(sizeof(char *) * 2);
123
110
if (new_plugin->argv == NULL){
124
free(copy_name);
125
free(new_plugin);
126
return NULL;
111
perror("malloc");
112
exit(EXIT_FAILURE);
127
113
}
128
new_plugin->argv[0] = copy_name;
114
new_plugin->argv[0] = name;
129
115
new_plugin->argv[1] = NULL;
130
131
new_plugin->environ = malloc(sizeof(char *));
132
if(new_plugin->environ == NULL){
133
free(copy_name);
134
free(new_plugin->argv);
135
free(new_plugin);
136
return NULL;
137
}
138
new_plugin->environ[0] = NULL;
116
new_plugin->argc = 1;
117
new_plugin->disabled = false;
118
new_plugin->next = *plugin_list;
139
119
/* Append the new plugin to the list */
140
120
*plugin_list = new_plugin;
141
121
return new_plugin;
142
122
}
143
123
144
/* Helper function for add_argument and add_environment */
145
static bool add_to_char_array(const char *new, char ***array,
146
int *len){
147
/* Resize the pointed-to array to hold one more pointer */
148
*array = realloc(*array, sizeof(char *)
149
* (size_t) ((*len) + 2));
150
/* Malloc check */
151
if(*array == NULL){
152
return false;
153
}
154
/* Make a copy of the new string */
155
char *copy = strdup(new);
156
if(copy == NULL){
157
return false;
158
}
159
/* Insert the copy */
160
(*array)[*len] = copy;
161
(*len)++;
162
/* Add a new terminating NULL pointer to the last element */
163
(*array)[*len] = NULL;
164
return true;
165
}
166
167
/* Add to a plugin's argument vector */
168
static bool add_argument(plugin *p, const char *arg){
169
if(p == NULL){
170
return false;
171
}
172
return add_to_char_array(arg, &(p->argv), &(p->argc));
173
}
174
175
/* Add to a plugin's environment */
176
static bool add_environment(plugin *p, const char *def){
177
if(p == NULL){
178
return false;
179
}
180
return add_to_char_array(def, &(p->environ), &(p->envc));
181
}
182
124
static void addargument(plugin *p, char *arg){
125
p->argv[p->argc] = arg;
126
p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
127
if (p->argv == NULL){
128
perror("malloc");
129
exit(EXIT_FAILURE);
130
}
131
p->argc++;
132
p->argv[p->argc] = NULL;
133
}
183
134
184
135
/*
185
136
* Based on the example in the GNU LibC manual chapter 13.13 "File
235
186
return true;
236
187
}
237
188
238
char **add_to_argv(char **argv, int *argc, char *arg){
189
char ** addcustomargument(char **argv, int *argc, char *arg){
190
239
191
if (argv == NULL){
240
192
*argc = 1;
241
193
argv = malloc(sizeof(char*) * 2);
256
208
return argv;
257
209
}
258
210
259
static void free_plugin_list(plugin *plugin_list){
260
for(plugin *next = plugin_list; plugin_list != NULL; plugin_list = next){
261
next = plugin_list->next;
262
free(plugin_list->name);
263
for(char **arg = plugin_list->argv; *arg != NULL; arg++){
264
free(*arg);
265
}
266
free(plugin_list->argv);
267
for(char **env = plugin_list->environ; *env != NULL; env++){
268
free(*env);
269
}
270
free(plugin_list->environ);
271
free(plugin_list);
272
}
273
}
274
275
211
int main(int argc, char *argv[]){
276
const char *plugindir = "/lib/mandos/plugins.d";
277
const char *argfile = ARGFILE;
212
const char *plugindir = "/conf/conf.d/mandos/plugins.d";
213
const char *conffile = CONFFILE;
278
214
FILE *conffp;
279
215
size_t d_name_len;
280
216
DIR *dir = NULL;
295
231
/* Establish a signal handler */
296
232
sigemptyset(&sigchld_action.sa_mask);
297
233
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
298
if(ret == -1){
234
if(ret < 0){
299
235
perror("sigaddset");
300
exitstatus = EXIT_FAILURE;
301
goto fallback;
236
exit(EXIT_FAILURE);
302
237
}
303
238
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
304
if(ret == -1){
239
if(ret < 0){
305
240
perror("sigaction");
306
exitstatus = EXIT_FAILURE;
307
goto fallback;
241
exit(EXIT_FAILURE);
308
242
}
309
243
310
244
/* The options we understand. */
312
246
{ .name = "global-options", .key = 'g',
313
247
.arg = "OPTION[,OPTION[,...]]",
314
248
.doc = "Options passed to all plugins" },
315
{ .name = "global-envs", .key = 'e',
316
.arg = "VAR=value",
317
.doc = "Environment variable passed to all plugins" },
318
249
{ .name = "options-for", .key = 'o',
319
250
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
320
251
.doc = "Options passed only to specified plugin" },
321
{ .name = "envs-for", .key = 'f',
322
.arg = "PLUGIN:ENV=value",
323
.doc = "Environment variable passed to specified plugin" },
324
252
{ .name = "disable", .key = 'd',
325
253
.arg = "PLUGIN",
326
254
.doc = "Disable a specific plugin", .group = 1 },
350
278
if(p[0] == '\0'){
351
279
continue;
352
280
}
353
if(not add_argument(getplugin(NULL, plugins), p)){
354
perror("add_argument");
355
return ARGP_ERR_UNKNOWN;
356
}
357
}
358
}
359
break;
360
case 'e':
361
if(arg == NULL){
362
break;
363
}
364
{
365
char *envdef = strdup(arg);
366
if(envdef == NULL){
367
break;
368
}
369
if(not add_environment(getplugin(NULL, plugins), envdef)){
370
perror("add_environment");
281
addargument(getplugin(NULL, plugins), p);
371
282
}
372
283
}
373
284
break;
374
285
case 'o':
375
286
if (arg != NULL){
376
char *p_name = strsep(&arg, ":");
377
if(p_name[0] == '\0'){
287
char *name = strsep(&arg, ":");
288
if(name[0] == '\0'){
378
289
break;
379
290
}
380
291
char *opt = strsep(&arg, ":");
387
298
if(p[0] == '\0'){
388
299
continue;
389
300
}
390
if(not add_argument(getplugin(p_name, plugins), p)){
391
perror("add_argument");
392
return ARGP_ERR_UNKNOWN;
393
}
301
addargument(getplugin(name, plugins), p);
394
302
}
395
303
}
396
304
}
397
305
break;
398
case 'f':
399
if(arg == NULL){
400
break;
401
}
402
{
403
char *envdef = strchr(arg, ':');
404
if(envdef == NULL){
405
break;
406
}
407
char *p_name = strndup(arg, (size_t) (envdef-arg));
408
if(p_name == NULL){
409
break;
410
}
411
envdef++;
412
if(not add_environment(getplugin(p_name, plugins), envdef)){
413
perror("add_environment");
414
}
415
}
416
break;
417
306
case 'd':
418
307
if (arg != NULL){
419
plugin *p = getplugin(arg, plugins);
420
if(p == NULL){
421
return ARGP_ERR_UNKNOWN;
422
}
423
p->disabled = true;
308
getplugin(arg, plugins)->disabled = true;
424
309
}
425
310
break;
426
311
case 128:
436
321
debug = true;
437
322
break;
438
323
case ARGP_KEY_ARG:
439
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
324
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
440
325
break;
441
326
case ARGP_KEY_END:
442
327
break;
456
341
if (ret == ARGP_ERR_UNKNOWN){
457
342
fprintf(stderr, "Unknown error while parsing arguments\n");
458
343
exitstatus = EXIT_FAILURE;
459
goto fallback;
344
goto end;
460
345
}
461
346
462
conffp = fopen(argfile, "r");
347
conffp = fopen(conffile, "r");
463
348
if(conffp != NULL){
464
349
char *org_line = NULL;
465
char *p, *arg, *new_arg, *line;
466
350
size_t size = 0;
467
351
ssize_t sret;
352
char *p, *arg, *new_arg, *line;
468
353
const char whitespace_delims[] = " \r\t\f\v\n";
469
354
const char comment_delim[] = "#";
470
355
481
366
continue;
482
367
}
483
368
new_arg = strdup(p);
484
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
369
custom_argv = addcustomargument(custom_argv, &custom_argc, new_arg);
485
370
if (custom_argv == NULL){
486
perror("add_to_argv");
371
perror("addcustomargument");
487
372
exitstatus = EXIT_FAILURE;
488
goto fallback;
373
goto end;
489
374
}
490
375
}
491
376
}
492
377
free(org_line);
493
378
} else{
494
/* Check for harmful errors and go to fallback. Other errors might
495
not affect opening plugins */
379
/* check for harmfull errors */
496
380
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
497
381
perror("fopen");
498
382
exitstatus = EXIT_FAILURE;
499
goto fallback;
383
goto end;
500
384
}
501
385
}
502
386
506
390
if (ret == ARGP_ERR_UNKNOWN){
507
391
fprintf(stderr, "Unknown error while parsing arguments\n");
508
392
exitstatus = EXIT_FAILURE;
509
goto fallback;
393
goto end;
510
394
}
511
395
}
512
396
517
401
for(char **a = p->argv; *a != NULL; a++){
518
402
fprintf(stderr, "\tArg: %s\n", *a);
519
403
}
520
fprintf(stderr, "...and %u environment variables\n", p->envc);
521
for(char **a = p->environ; *a != NULL; a++){
522
fprintf(stderr, "\t%s\n", *a);
523
}
524
404
}
525
405
}
526
406
538
418
if(dir == NULL){
539
419
perror("Could not open plugin dir");
540
420
exitstatus = EXIT_FAILURE;
541
goto fallback;
421
goto end;
542
422
}
543
423
544
424
/* Set the FD_CLOEXEC flag on the directory, if possible */
549
429
if(ret < 0){
550
430
perror("set_cloexec_flag");
551
431
exitstatus = EXIT_FAILURE;
552
goto fallback;
432
goto end;
553
433
}
554
434
}
555
435
}
564
444
if (errno == EBADF){
565
445
perror("readdir");
566
446
exitstatus = EXIT_FAILURE;
567
goto fallback;
447
goto end;
568
448
}
569
449
break;
570
450
}
615
495
continue;
616
496
}
617
497
}
618
619
char *filename;
620
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
621
if(ret < 0){
622
perror("asprintf");
498
499
char *filename = malloc(d_name_len + strlen(plugindir) + 2);
500
if (filename == NULL){
501
perror("malloc");
623
502
continue;
624
503
}
504
strcpy(filename, plugindir); /* Spurious warning */
505
strcat(filename, "/"); /* Spurious warning */
506
strcat(filename, dirst->d_name); /* Spurious warning */
625
507
626
508
ret = stat(filename, &st);
627
509
if (ret == -1){
638
520
free(filename);
639
521
continue;
640
522
}
641
plugin *p = getplugin(dirst->d_name, &plugin_list);
642
if(p == NULL){
643
perror("getplugin");
644
free(filename);
645
continue;
646
}
647
if(p->disabled){
523
if(getplugin(dirst->d_name, &plugin_list)->disabled){
648
524
if(debug){
649
525
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
650
526
dirst->d_name);
652
528
free(filename);
653
529
continue;
654
530
}
531
plugin *p = getplugin(dirst->d_name, &plugin_list);
655
532
{
656
533
/* Add global arguments to argument list for this plugin */
657
534
plugin *g = getplugin(NULL, &plugin_list);
658
if(g != NULL){
659
for(char **a = g->argv + 1; *a != NULL; a++){
660
if(not add_argument(p, *a)){
661
perror("add_argument");
662
}
663
}
664
/* Add global environment variables */
665
for(char **e = g->environ; *e != NULL; e++){
666
if(not add_environment(p, *e)){
667
perror("add_environment");
668
}
669
}
670
}
671
}
672
/* If this plugin has any environment variables, we will call
673
using execve and need to duplicate the environment from this
674
process, too. */
675
if(p->environ[0] != NULL){
676
for(char **e = environ; *e != NULL; e++){
677
char *copy = strdup(*e);
678
if(copy == NULL){
679
perror("strdup");
680
continue;
681
}
682
if(not add_environment(p, copy)){
683
perror("add_environment");
684
}
685
}
686
}
687
535
for(char **a = g->argv + 1; *a != NULL; a++){
536
addargument(p, *a);
537
}
538
}
688
539
int pipefd[2];
689
540
ret = pipe(pipefd);
690
541
if (ret == -1){
691
542
perror("pipe");
692
543
exitstatus = EXIT_FAILURE;
693
goto fallback;
544
goto end;
694
545
}
695
546
ret = set_cloexec_flag(pipefd[0]);
696
547
if(ret < 0){
697
548
perror("set_cloexec_flag");
698
549
exitstatus = EXIT_FAILURE;
699
goto fallback;
550
goto end;
700
551
}
701
552
ret = set_cloexec_flag(pipefd[1]);
702
553
if(ret < 0){
703
554
perror("set_cloexec_flag");
704
555
exitstatus = EXIT_FAILURE;
705
goto fallback;
556
goto end;
706
557
}
707
558
/* Block SIGCHLD until process is safely in process list */
708
559
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
709
560
if(ret < 0){
710
561
perror("sigprocmask");
711
562
exitstatus = EXIT_FAILURE;
712
goto fallback;
563
goto end;
713
564
}
714
565
// Starting a new process to be watched
715
566
pid_t pid = fork();
716
567
if(pid == -1){
717
568
perror("fork");
718
569
exitstatus = EXIT_FAILURE;
719
goto fallback;
570
goto end;
720
571
}
721
572
if(pid == 0){
722
573
/* this is the child process */
742
593
above and must now close it manually here. */
743
594
closedir(dir);
744
595
}
745
if(p->environ[0] == NULL){
746
if(execv(filename, p->argv) < 0){
747
perror("execv");
748
_exit(EXIT_FAILURE);
749
}
750
} else {
751
if(execve(filename, p->argv, p->environ) < 0){
752
perror("execve");
753
_exit(EXIT_FAILURE);
754
}
596
if(execv(filename, p->argv) < 0){
597
perror("execv");
598
_exit(EXIT_FAILURE);
755
599
}
756
600
/* no return */
757
601
}
766
610
perror("sigprocmask");
767
611
}
768
612
exitstatus = EXIT_FAILURE;
769
goto fallback;
613
goto end;
770
614
}
771
615
772
616
*new_process = (struct process){ .pid = pid,
780
624
if(ret < 0){
781
625
perror("sigprocmask");
782
626
exitstatus = EXIT_FAILURE;
783
goto fallback;
627
goto end;
784
628
}
785
629
786
630
FD_SET(new_process->fd, &rfds_all);
791
635
792
636
}
793
637
794
free_plugin_list(plugin_list);
638
/* Free the plugin list */
639
for(plugin *next; plugin_list != NULL; plugin_list = next){
640
next = plugin_list->next;
641
free(plugin_list->argv);
642
free(plugin_list);
643
}
795
644
796
645
closedir(dir);
797
646
dir = NULL;
807
656
if (select_ret == -1){
808
657
perror("select");
809
658
exitstatus = EXIT_FAILURE;
810
goto fallback;
659
goto end;
811
660
}
812
661
/* OK, now either a process completed, or something can be read
813
662
from one of them */
839
688
if(ret < 0){
840
689
perror("sigprocmask");
841
690
exitstatus = EXIT_FAILURE;
842
goto fallback;
691
goto end;
843
692
}
844
693
/* Delete this process entry from the list */
845
694
if(process_list == proc){
874
723
perror("print_out_password");
875
724
exitstatus = EXIT_FAILURE;
876
725
}
877
goto fallback;
726
goto end;
878
727
}
879
728
/* This process has not completed. Does it have any output? */
880
729
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
888
737
if (proc->buffer == NULL){
889
738
perror("malloc");
890
739
exitstatus = EXIT_FAILURE;
891
goto fallback;
740
goto end;
892
741
}
893
742
proc->buffer_size += BUFFER_SIZE;
894
743
}
909
758
}
910
759
911
760
912
fallback:
761
end:
913
762
914
763
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
915
764
/* Fallback if all plugins failed, none are found or an error occured */
920
769
if(not bret){
921
770
perror("print_out_password");
922
771
exitstatus = EXIT_FAILURE;
772
goto end;
923
773
}
924
774
}
925
775
926
776
/* Restore old signal handler */
927
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
928
if(ret == -1){
929
perror("sigaction");
930
exitstatus = EXIT_FAILURE;
931
}
932
933
if(custom_argv != NULL){
934
for(char **arg = custom_argv; *arg != NULL; arg++){
935
free(*arg);
936
}
937
free(custom_argv);
938
}
939
free_plugin_list(plugin_list);
777
sigaction(SIGCHLD, &old_sigchld_action, NULL);
778
779
free(custom_argv);
780
781
/* Free the plugin list */
782
for(plugin *next; plugin_list != NULL; plugin_list = next){
783
next = plugin_list->next;
784
free(plugin_list->argv);
785
free(plugin_list);
786
}
940
787
941
788
if(dir != NULL){
942
789
closedir(dir);
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0