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