To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugin-runner.c
- browse files at revision 237.7.780
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.780
- Committer: Teddy Hogeborn
- Date: 2021-02-01 19:30:45 UTC
- mto: This revision was merged to the branch mainline in revision 404.
- Revision ID: teddy@recompile.se-20210201193045-lpg6aprpc4srem6k
Fix issue with french translation
Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation. The string is a raw command line command, and therefore
did not need translation, so this was never a user-visible issue.
* debian/po/fr.po: Add missing whitespace to the id and translation
for msgid " mandos-keygen -F/dev/null|grep ^key_id".
Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation. The string is a raw command line command, and therefore
did not need translation, so this was never a user-visible issue.
* debian/po/fr.po: Add missing whitespace to the id and translation
for msgid " mandos-keygen -F/dev/null|grep ^key_id".
- files added:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/tests
- debian/upstream
- dracut-module
- network-hooks.d
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files renamed:
- plugins.d/password-request.c => plugins.d/mandos-client.c
- plugins.d/password-request.xml => plugins.d/mandos-client.xml
- files modified:
- Makefile
added
removed
plugin-runner.c
1
/* -*- coding: utf-8 -*- */
1
/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
3
* Mandos plugin runner - Run Mandos plugins
4
4
*
5
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
*
7
* This program is free software: you can redistribute it and/or
8
* modify it under the terms of the GNU General Public License as
9
* published by the Free Software Foundation, either version 3 of the
10
* License, or (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful, but
5
* Copyright © 2008-2020 Teddy Hogeborn
6
* Copyright © 2008-2020 Björn Påhlsson
7
*
8
* This file is part of Mandos.
9
*
10
* Mandos is free software: you can redistribute it and/or modify it
11
* under the terms of the GNU General Public License as published by
12
* the Free Software Foundation, either version 3 of the License, or
13
* (at your option) any later version.
14
*
15
* Mandos is distributed in the hope that it will be useful, but
13
16
* WITHOUT ANY WARRANTY; without even the implied warranty of
14
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
18
* General Public License for more details.
16
19
*
17
20
* You should have received a copy of the GNU General Public License
18
* along with this program. If not, see
19
* <http://www.gnu.org/licenses/>.
21
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
20
22
*
21
* Contact the authors at <mandos@fukt.bsnet.se>.
23
* Contact the authors at <mandos@recompile.se>.
22
24
*/
23
25
24
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
25
26
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
27
O_CLOEXEC, pipe2() */
26
28
#include <stddef.h> /* size_t, NULL */
27
#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,
28
EXIT_SUCCESS, realloc() */
29
#include <stdlib.h> /* malloc(), reallocarray(), realloc(),
30
EXIT_SUCCESS, exit() */
29
31
#include <stdbool.h> /* bool, true, false */
30
#include <stdio.h> /* perror, popen(), fileno(),
31
fprintf(), stderr, STDOUT_FILENO */
32
#include <sys/types.h> /* DIR, opendir(), stat(), struct
33
stat, waitpid(), WIFEXITED(),
34
WEXITSTATUS(), wait(), pid_t,
35
uid_t, gid_t, getuid(), getgid(),
36
dirfd() */
32
#include <stdio.h> /* fileno(), fprintf(),
33
stderr, STDOUT_FILENO, fclose() */
34
#include <sys/types.h> /* fstat(), struct stat, waitpid(),
35
WIFEXITED(), WEXITSTATUS(), wait(),
36
pid_t, uid_t, gid_t, getuid(),
37
getgid() */
37
38
#include <sys/select.h> /* fd_set, select(), FD_ZERO(),
38
39
FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),
40
WEXITSTATUS() */
41
#include <sys/stat.h> /* struct stat, stat(), S_ISREG() */
41
WEXITSTATUS(), WTERMSIG() */
42
#include <sys/stat.h> /* struct stat, fstat(), S_ISREG() */
42
43
#include <iso646.h> /* and, or, not */
43
#include <dirent.h> /* DIR, struct dirent, opendir(),
44
readdir(), closedir(), dirfd() */
45
#include <unistd.h> /* struct stat, stat(), S_ISREG(),
46
fcntl(), setuid(), setgid(),
47
F_GETFD, F_SETFD, FD_CLOEXEC,
48
access(), pipe(), fork(), close()
49
dup2, STDOUT_FILENO, _exit(),
50
execv(), write(), read(),
51
close() */
44
#include <dirent.h> /* struct dirent, scandirat() */
45
#include <unistd.h> /* fcntl(), F_GETFD, F_SETFD,
46
FD_CLOEXEC, write(), STDOUT_FILENO,
47
struct stat, fstat(), close(),
48
setgid(), setuid(), S_ISREG(),
49
faccessat() pipe2(), fork(),
50
_exit(), dup2(), fexecve(), read(),
51
lstat(), symlink() */
52
52
#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,
53
FD_CLOEXEC */
54
#include <string.h> /* strsep, strlen(), strcpy(),
55
strcat() */
53
FD_CLOEXEC, openat(), scandirat(),
54
pipe2() */
55
#include <string.h> /* strsep, strlen(), strsignal(),
56
strcmp(), strncmp() */
56
57
#include <errno.h> /* errno */
57
58
#include <argp.h> /* struct argp_option, struct
58
59
argp_state, struct argp,
59
60
argp_parse(), ARGP_ERR_UNKNOWN,
60
ARGP_KEY_END, ARGP_KEY_ARG, error_t */
61
ARGP_KEY_END, ARGP_KEY_ARG,
62
error_t */
61
63
#include <signal.h> /* struct sigaction, sigemptyset(),
62
64
sigaddset(), sigaction(),
63
65
sigprocmask(), SIG_BLOCK, SIGCHLD,
64
SIG_UNBLOCK, kill() */
66
SIG_UNBLOCK, kill(), sig_atomic_t
67
*/
65
68
#include <errno.h> /* errno, EBADF */
69
#include <inttypes.h> /* intmax_t, PRIdMAX, strtoimax() */
70
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,
71
EX_CONFIG, EX_UNAVAILABLE, EX_OK */
72
#include <errno.h> /* errno */
73
#include <error.h> /* error() */
74
#include <fnmatch.h> /* fnmatch() */
66
75
67
76
#define BUFFER_SIZE 256
68
77
69
const char *argp_program_version = "plugin-runner 1.0";
70
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
71
72
struct process;
73
74
typedef struct process{
78
#define PDIR "/lib/mandos/plugins.d"
79
#define PHDIR "/lib/mandos/plugin-helpers"
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
81
82
const char *argp_program_version = "plugin-runner " VERSION;
83
const char *argp_program_bug_address = "<mandos@recompile.se>";
84
85
typedef struct plugin{
86
char *name; /* can be NULL or any plugin name */
87
char **argv;
88
int argc;
89
char **environ;
90
int envc;
91
bool disabled;
92
93
/* Variables used for running processes*/
75
94
pid_t pid;
76
95
int fd;
77
96
char *buffer;
78
97
size_t buffer_size;
79
98
size_t buffer_length;
80
99
bool eof;
81
bool completed;
100
volatile sig_atomic_t completed;
82
101
int status;
83
struct process *next;
84
} process;
85
86
typedef struct plugin{
87
char *name; /* can be NULL or any plugin name */
88
char **argv;
89
int argc;
90
bool disabled;
91
102
struct plugin *next;
92
103
} plugin;
93
104
94
static plugin *getplugin(char *name, plugin **plugin_list){
95
for (plugin *p = *plugin_list; p != NULL; p = p->next){
96
if ((p->name == name)
97
or (p->name and name and (strcmp(p->name, name) == 0))){
105
static plugin *plugin_list = NULL;
106
107
/* Gets an existing plugin based on name,
108
or if none is found, creates a new one */
109
__attribute__((warn_unused_result))
110
static plugin *getplugin(char *name){
111
/* Check for existing plugin with that name */
112
for(plugin *p = plugin_list; p != NULL; p = p->next){
113
if((p->name == name)
114
or (p->name and name and (strcmp(p->name, name) == 0))){
98
115
return p;
99
116
}
100
117
}
101
118
/* Create a new plugin */
102
plugin *new_plugin = malloc(sizeof(plugin));
103
if (new_plugin == NULL){
104
perror("malloc");
105
exit(EXIT_FAILURE);
106
}
107
new_plugin->name = name;
108
new_plugin->argv = malloc(sizeof(char *) * 2);
109
if (new_plugin->argv == NULL){
110
perror("malloc");
111
exit(EXIT_FAILURE);
112
}
113
new_plugin->argv[0] = name;
119
plugin *new_plugin = NULL;
120
do {
121
new_plugin = malloc(sizeof(plugin));
122
} while(new_plugin == NULL and errno == EINTR);
123
if(new_plugin == NULL){
124
return NULL;
125
}
126
char *copy_name = NULL;
127
if(name != NULL){
128
do {
129
copy_name = strdup(name);
130
} while(copy_name == NULL and errno == EINTR);
131
if(copy_name == NULL){
132
int e = errno;
133
free(new_plugin);
134
errno = e;
135
return NULL;
136
}
137
}
138
139
*new_plugin = (plugin){ .name = copy_name,
140
.argc = 1,
141
.disabled = false,
142
.next = plugin_list };
143
144
do {
145
new_plugin->argv = malloc(sizeof(char *) * 2);
146
} while(new_plugin->argv == NULL and errno == EINTR);
147
if(new_plugin->argv == NULL){
148
int e = errno;
149
free(copy_name);
150
free(new_plugin);
151
errno = e;
152
return NULL;
153
}
154
new_plugin->argv[0] = copy_name;
114
155
new_plugin->argv[1] = NULL;
115
new_plugin->argc = 1;
116
new_plugin->disabled = false;
117
new_plugin->next = *plugin_list;
156
157
do {
158
new_plugin->environ = malloc(sizeof(char *));
159
} while(new_plugin->environ == NULL and errno == EINTR);
160
if(new_plugin->environ == NULL){
161
int e = errno;
162
free(copy_name);
163
free(new_plugin->argv);
164
free(new_plugin);
165
errno = e;
166
return NULL;
167
}
168
new_plugin->environ[0] = NULL;
169
118
170
/* Append the new plugin to the list */
119
*plugin_list = new_plugin;
171
plugin_list = new_plugin;
120
172
return new_plugin;
121
173
}
122
174
123
static void addargument(plugin *p, char *arg){
124
p->argv[p->argc] = arg;
125
p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
126
if (p->argv == NULL){
127
perror("malloc");
128
exit(EXIT_FAILURE);
129
}
130
p->argc++;
131
p->argv[p->argc] = NULL;
132
}
133
175
/* Helper function for add_argument and add_environment */
176
__attribute__((nonnull, warn_unused_result))
177
static bool add_to_char_array(const char *new, char ***array,
178
int *len){
179
/* Resize the pointed-to array to hold one more pointer */
180
char **new_array = NULL;
181
do {
182
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
183
new_array = reallocarray(*array, (size_t)((*len) + 2),
184
sizeof(char *));
185
#else
186
if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
187
/* overflow */
188
new_array = NULL;
189
errno = ENOMEM;
190
} else {
191
new_array = realloc(*array, (size_t)((*len) + 2)
192
* sizeof(char *));
193
}
194
#endif
195
} while(new_array == NULL and errno == EINTR);
196
/* Malloc check */
197
if(new_array == NULL){
198
return false;
199
}
200
*array = new_array;
201
/* Make a copy of the new string */
202
char *copy;
203
do {
204
copy = strdup(new);
205
} while(copy == NULL and errno == EINTR);
206
if(copy == NULL){
207
return false;
208
}
209
/* Insert the copy */
210
(*array)[*len] = copy;
211
(*len)++;
212
/* Add a new terminating NULL pointer to the last element */
213
(*array)[*len] = NULL;
214
return true;
215
}
216
217
/* Add to a plugin's argument vector */
218
__attribute__((nonnull(2), warn_unused_result))
219
static bool add_argument(plugin *p, const char *arg){
220
if(p == NULL){
221
return false;
222
}
223
return add_to_char_array(arg, &(p->argv), &(p->argc));
224
}
225
226
/* Add to a plugin's environment */
227
__attribute__((nonnull(2), warn_unused_result))
228
static bool add_environment(plugin *p, const char *def, bool replace){
229
if(p == NULL){
230
return false;
231
}
232
/* namelen = length of name of environment variable */
233
size_t namelen = (size_t)(strchrnul(def, '=') - def);
234
/* Search for this environment variable */
235
for(char **envdef = p->environ; *envdef != NULL; envdef++){
236
if(strncmp(*envdef, def, namelen + 1) == 0){
237
/* It already exists */
238
if(replace){
239
char *new_envdef;
240
do {
241
new_envdef = realloc(*envdef, strlen(def) + 1);
242
} while(new_envdef == NULL and errno == EINTR);
243
if(new_envdef == NULL){
244
return false;
245
}
246
*envdef = new_envdef;
247
strcpy(*envdef, def);
248
}
249
return true;
250
}
251
}
252
return add_to_char_array(def, &(p->environ), &(p->envc));
253
}
254
255
#ifndef O_CLOEXEC
134
256
/*
135
257
* Based on the example in the GNU LibC manual chapter 13.13 "File
136
258
* Descriptor Flags".
137
* *Note File Descriptor Flags:(libc)Descriptor Flags.
259
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
138
260
*/
139
static int set_cloexec_flag(int fd)
140
{
141
int ret = fcntl(fd, F_GETFD, 0);
261
__attribute__((warn_unused_result))
262
static int set_cloexec_flag(int fd){
263
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
142
264
/* If reading the flags failed, return error indication now. */
143
265
if(ret < 0){
144
266
return ret;
145
267
}
146
268
/* Store modified flag word in the descriptor. */
147
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
269
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
270
ret | FD_CLOEXEC));
148
271
}
149
150
process *process_list = NULL;
151
152
/* Mark a process as completed when it exits, and save its exit
272
#endif /* not O_CLOEXEC */
273
274
275
/* Mark processes as completed when they exit, and save their exit
153
276
status. */
154
void handle_sigchld(__attribute__((unused)) int sig){
155
process *proc = process_list;
156
int status;
157
pid_t pid = wait(&status);
158
if(pid == -1){
159
perror("wait");
160
return;
161
}
162
while(proc != NULL and proc->pid != pid){
163
proc = proc->next;
164
}
165
if(proc == NULL){
166
/* Process not found in process list */
167
return;
168
}
169
proc->status = status;
170
proc->completed = true;
277
static void handle_sigchld(__attribute__((unused)) int sig){
278
int old_errno = errno;
279
while(true){
280
plugin *proc = plugin_list;
281
int status;
282
pid_t pid = waitpid(-1, &status, WNOHANG);
283
if(pid == 0){
284
/* Only still running child processes */
285
break;
286
}
287
if(pid == -1){
288
if(errno == ECHILD){
289
/* No child processes */
290
break;
291
}
292
error(0, errno, "waitpid");
293
}
294
295
/* A child exited, find it in process_list */
296
while(proc != NULL and proc->pid != pid){
297
proc = proc->next;
298
}
299
if(proc == NULL){
300
/* Process not found in process list */
301
continue;
302
}
303
proc->status = status;
304
proc->completed = 1;
305
}
306
errno = old_errno;
171
307
}
172
308
173
bool print_out_password(const char *buffer, size_t length){
309
/* Prints out a password to stdout */
310
__attribute__((nonnull, warn_unused_result))
311
static bool print_out_password(const char *buffer, size_t length){
174
312
ssize_t ret;
175
if(length>0 and buffer[length-1] == '\n'){
176
length--;
177
}
178
313
for(size_t written = 0; written < length; written += (size_t)ret){
179
314
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
180
315
length - written));
185
320
return true;
186
321
}
187
322
323
/* Removes and free a plugin from the plugin list */
324
__attribute__((nonnull))
325
static void free_plugin(plugin *plugin_node){
326
327
for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
328
free(*arg);
329
}
330
free(plugin_node->name);
331
free(plugin_node->argv);
332
for(char **env = plugin_node->environ; *env != NULL; env++){
333
free(*env);
334
}
335
free(plugin_node->environ);
336
free(plugin_node->buffer);
337
338
/* Removes the plugin from the singly-linked list */
339
if(plugin_node == plugin_list){
340
/* First one - simple */
341
plugin_list = plugin_list->next;
342
} else {
343
/* Second one or later */
344
for(plugin *p = plugin_list; p != NULL; p = p->next){
345
if(p->next == plugin_node){
346
p->next = plugin_node->next;
347
break;
348
}
349
}
350
}
351
352
free(plugin_node);
353
}
354
355
static void free_plugin_list(void){
356
while(plugin_list != NULL){
357
free_plugin(plugin_list);
358
}
359
}
360
188
361
int main(int argc, char *argv[]){
189
const char *plugindir = "/lib/mandos/plugins.d";
190
size_t d_name_len;
191
DIR *dir = NULL;
192
struct dirent *dirst;
362
char *plugindir = NULL;
363
char *pluginhelperdir = NULL;
364
char *argfile = NULL;
365
FILE *conffp;
366
struct dirent **direntries = NULL;
193
367
struct stat st;
194
368
fd_set rfds_all;
195
369
int ret, maxfd = 0;
370
ssize_t sret;
196
371
uid_t uid = 65534;
197
372
gid_t gid = 65534;
198
373
bool debug = false;
200
375
struct sigaction old_sigchld_action;
201
376
struct sigaction sigchld_action = { .sa_handler = handle_sigchld,
202
377
.sa_flags = SA_NOCLDSTOP };
203
char *plus_options = NULL;
204
char **plus_argv = NULL;
205
378
char **custom_argv = NULL;
379
int custom_argc = 0;
380
int dir_fd = -1;
381
206
382
/* Establish a signal handler */
207
383
sigemptyset(&sigchld_action.sa_mask);
208
384
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
209
if(ret < 0){
210
perror("sigaddset");
211
exit(EXIT_FAILURE);
385
if(ret == -1){
386
error(0, errno, "sigaddset");
387
exitstatus = EX_OSERR;
388
goto fallback;
212
389
}
213
390
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
214
if(ret < 0){
215
perror("sigaction");
216
exit(EXIT_FAILURE);
391
if(ret == -1){
392
error(0, errno, "sigaction");
393
exitstatus = EX_OSERR;
394
goto fallback;
217
395
}
218
396
219
397
/* The options we understand. */
221
399
{ .name = "global-options", .key = 'g',
222
400
.arg = "OPTION[,OPTION[,...]]",
223
401
.doc = "Options passed to all plugins" },
402
{ .name = "global-env", .key = 'G',
403
.arg = "VAR=value",
404
.doc = "Environment variable passed to all plugins" },
224
405
{ .name = "options-for", .key = 'o',
225
406
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
226
407
.doc = "Options passed only to specified plugin" },
408
{ .name = "env-for", .key = 'E',
409
.arg = "PLUGIN:ENV=value",
410
.doc = "Environment variable passed to specified plugin" },
227
411
{ .name = "disable", .key = 'd',
228
412
.arg = "PLUGIN",
229
413
.doc = "Disable a specific plugin", .group = 1 },
414
{ .name = "enable", .key = 'e',
415
.arg = "PLUGIN",
416
.doc = "Enable a specific plugin", .group = 1 },
230
417
{ .name = "plugin-dir", .key = 128,
231
418
.arg = "DIRECTORY",
232
419
.doc = "Specify a different plugin directory", .group = 2 },
233
{ .name = "userid", .key = 129,
234
.arg = "ID", .flags = 0,
235
.doc = "User ID the plugins will run as", .group = 2 },
236
{ .name = "groupid", .key = 130,
237
.arg = "ID", .flags = 0,
238
.doc = "Group ID the plugins will run as", .group = 2 },
239
{ .name = "debug", .key = 131,
240
.doc = "Debug mode", .group = 3 },
420
{ .name = "config-file", .key = 129,
421
.arg = "FILE",
422
.doc = "Specify a different configuration file", .group = 2 },
423
{ .name = "userid", .key = 130,
424
.arg = "ID", .flags = 0,
425
.doc = "User ID the plugins will run as", .group = 3 },
426
{ .name = "groupid", .key = 131,
427
.arg = "ID", .flags = 0,
428
.doc = "Group ID the plugins will run as", .group = 3 },
429
{ .name = "debug", .key = 132,
430
.doc = "Debug mode", .group = 4 },
431
{ .name = "plugin-helper-dir", .key = 133,
432
.arg = "DIRECTORY",
433
.doc = "Specify a different plugin helper directory",
434
.group = 2 },
435
/*
436
* These reproduce what we would get without ARGP_NO_HELP
437
*/
438
{ .name = "help", .key = '?',
439
.doc = "Give this help list", .group = -1 },
440
{ .name = "usage", .key = -3,
441
.doc = "Give a short usage message", .group = -1 },
442
{ .name = "version", .key = 'V',
443
.doc = "Print program version", .group = -1 },
241
444
{ .name = NULL }
242
445
};
243
446
244
error_t parse_opt (int key, char *arg, struct argp_state *state) {
245
/* Get the INPUT argument from `argp_parse', which we know is a
246
pointer to our plugin list pointer. */
247
plugin **plugins = state->input;
248
switch (key) {
249
case 'g':
250
if (arg != NULL){
251
char *p;
252
while((p = strsep(&arg, ",")) != NULL){
253
if(strcmp(p, "") == 0){
254
continue;
255
}
256
addargument(getplugin(NULL, plugins), p);
257
}
258
}
259
break;
260
case 'o':
261
if (arg != NULL){
262
char *name = strsep(&arg, ":");
263
if(strcmp(name, "") == 0){
264
break;
265
}
266
char *opt = strsep(&arg, ":");
267
if(strcmp(opt, "") == 0){
268
break;
269
}
270
if(opt != NULL){
271
char *p;
272
while((p = strsep(&opt, ",")) != NULL){
273
if(strcmp(p, "") == 0){
274
continue;
275
}
276
addargument(getplugin(name, plugins), p);
277
}
278
}
279
}
280
break;
281
case 'd':
282
if (arg != NULL){
283
getplugin(arg, plugins)->disabled = true;
284
}
285
break;
286
case 128:
287
plugindir = arg;
288
break;
289
case 129:
290
uid = (uid_t)strtol(arg, NULL, 10);
291
break;
292
case 130:
293
gid = (gid_t)strtol(arg, NULL, 10);
294
break;
295
case 131:
447
__attribute__((nonnull(3)))
448
error_t parse_opt(int key, char *arg, struct argp_state *state){
449
errno = 0;
450
switch(key){
451
char *tmp;
452
intmax_t tmp_id;
453
case 'g': /* --global-options */
454
{
455
char *plugin_option;
456
while((plugin_option = strsep(&arg, ",")) != NULL){
457
if(not add_argument(getplugin(NULL), plugin_option)){
458
break;
459
}
460
}
461
errno = 0;
462
}
463
break;
464
case 'G': /* --global-env */
465
if(add_environment(getplugin(NULL), arg, true)){
466
errno = 0;
467
}
468
break;
469
case 'o': /* --options-for */
470
{
471
char *option_list = strchr(arg, ':');
472
if(option_list == NULL){
473
argp_error(state, "No colon in \"%s\"", arg);
474
errno = EINVAL;
475
break;
476
}
477
*option_list = '\0';
478
option_list++;
479
if(arg[0] == '\0'){
480
argp_error(state, "Empty plugin name");
481
errno = EINVAL;
482
break;
483
}
484
char *option;
485
while((option = strsep(&option_list, ",")) != NULL){
486
if(not add_argument(getplugin(arg), option)){
487
break;
488
}
489
}
490
errno = 0;
491
}
492
break;
493
case 'E': /* --env-for */
494
{
495
char *envdef = strchr(arg, ':');
496
if(envdef == NULL){
497
argp_error(state, "No colon in \"%s\"", arg);
498
errno = EINVAL;
499
break;
500
}
501
*envdef = '\0';
502
envdef++;
503
if(arg[0] == '\0'){
504
argp_error(state, "Empty plugin name");
505
errno = EINVAL;
506
break;
507
}
508
if(add_environment(getplugin(arg), envdef, true)){
509
errno = 0;
510
}
511
}
512
break;
513
case 'd': /* --disable */
514
{
515
plugin *p = getplugin(arg);
516
if(p != NULL){
517
p->disabled = true;
518
errno = 0;
519
}
520
}
521
break;
522
case 'e': /* --enable */
523
{
524
plugin *p = getplugin(arg);
525
if(p != NULL){
526
p->disabled = false;
527
errno = 0;
528
}
529
}
530
break;
531
case 128: /* --plugin-dir */
532
free(plugindir);
533
plugindir = strdup(arg);
534
if(plugindir != NULL){
535
errno = 0;
536
}
537
break;
538
case 129: /* --config-file */
539
/* This is already done by parse_opt_config_file() */
540
break;
541
case 130: /* --userid */
542
tmp_id = strtoimax(arg, &tmp, 10);
543
if(errno != 0 or tmp == arg or *tmp != '\0'
544
or tmp_id != (uid_t)tmp_id){
545
argp_error(state, "Bad user ID number: \"%s\", using %"
546
PRIdMAX, arg, (intmax_t)uid);
547
break;
548
}
549
uid = (uid_t)tmp_id;
550
errno = 0;
551
break;
552
case 131: /* --groupid */
553
tmp_id = strtoimax(arg, &tmp, 10);
554
if(errno != 0 or tmp == arg or *tmp != '\0'
555
or tmp_id != (gid_t)tmp_id){
556
argp_error(state, "Bad group ID number: \"%s\", using %"
557
PRIdMAX, arg, (intmax_t)gid);
558
break;
559
}
560
gid = (gid_t)tmp_id;
561
errno = 0;
562
break;
563
case 132: /* --debug */
296
564
debug = true;
297
565
break;
298
case ARGP_KEY_ARG:
299
if(plus_options != NULL or arg == NULL or arg[0] != '+'){
300
argp_usage (state);
301
}
302
plus_options = arg;
303
break;
304
case ARGP_KEY_END:
305
break;
306
default:
307
return ARGP_ERR_UNKNOWN;
308
}
309
return 0;
310
}
311
312
plugin *plugin_list = NULL;
313
314
struct argp argp = { .options = options, .parser = parse_opt,
315
.args_doc = "[+PLUS_SEPARATED_OPTIONS]",
566
case 133: /* --plugin-helper-dir */
567
free(pluginhelperdir);
568
pluginhelperdir = strdup(arg);
569
if(pluginhelperdir != NULL){
570
errno = 0;
571
}
572
break;
573
/*
574
* These reproduce what we would get without ARGP_NO_HELP
575
*/
576
case '?': /* --help */
577
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
578
argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
579
__builtin_unreachable();
580
case -3: /* --usage */
581
state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
582
argp_state_help(state, state->out_stream,
583
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
584
__builtin_unreachable();
585
case 'V': /* --version */
586
fprintf(state->out_stream, "%s\n", argp_program_version);
587
exit(EXIT_SUCCESS);
588
break;
589
/*
590
* When adding more options before this line, remember to also add a
591
* "case" to the "parse_opt_config_file" function below.
592
*/
593
case ARGP_KEY_ARG:
594
/* Cryptsetup always passes an argument, which is an empty
595
string if "none" was specified in /etc/crypttab. So if
596
argument was empty, we ignore it silently. */
597
if(arg[0] == '\0'){
598
break;
599
}
600
#if __GNUC__ >= 7
601
__attribute__((fallthrough));
602
#else
603
/* FALLTHROUGH */
604
#endif
605
default:
606
return ARGP_ERR_UNKNOWN;
607
}
608
return errno; /* Set to 0 at start */
609
}
610
611
/* This option parser is the same as parse_opt() above, except it
612
ignores everything but the --config-file option. */
613
error_t parse_opt_config_file(int key, char *arg,
614
__attribute__((unused))
615
struct argp_state *state){
616
errno = 0;
617
switch(key){
618
case 'g': /* --global-options */
619
case 'G': /* --global-env */
620
case 'o': /* --options-for */
621
case 'E': /* --env-for */
622
case 'd': /* --disable */
623
case 'e': /* --enable */
624
case 128: /* --plugin-dir */
625
break;
626
case 129: /* --config-file */
627
free(argfile);
628
argfile = strdup(arg);
629
if(argfile != NULL){
630
errno = 0;
631
}
632
break;
633
case 130: /* --userid */
634
case 131: /* --groupid */
635
case 132: /* --debug */
636
case 133: /* --plugin-helper-dir */
637
case '?': /* --help */
638
case -3: /* --usage */
639
case 'V': /* --version */
640
case ARGP_KEY_ARG:
641
break;
642
default:
643
return ARGP_ERR_UNKNOWN;
644
}
645
return errno;
646
}
647
648
struct argp argp = { .options = options,
649
.parser = parse_opt_config_file,
650
.args_doc = "",
316
651
.doc = "Mandos plugin runner -- Run plugins" };
317
652
318
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
319
if (ret == ARGP_ERR_UNKNOWN){
320
fprintf(stderr, "Unknown error while parsing arguments\n");
321
exitstatus = EXIT_FAILURE;
322
goto end;
323
}
324
325
if(plus_options){
326
/* This is a mangled argument in the form of
327
"+--option+--other-option=parameter+--yet-another-option", etc */
328
/* Make new argc and argv vars, and call argp_parse() again. */
329
plus_options++; /* skip the first '+' character */
330
const char delims[] = "+";
331
char *arg;
332
int new_argc = 1;
333
plus_argv = malloc(sizeof(char*) * 2);
334
if(plus_argv == NULL){
335
perror("malloc");
336
exitstatus = EXIT_FAILURE;
337
goto end;
338
}
339
plus_argv[0] = argv[0];
340
plus_argv[1] = NULL;
341
342
while((arg = strsep(&plus_options, delims)) != NULL){
343
new_argc++;
344
plus_argv = realloc(plus_argv, sizeof(char *)
345
* ((unsigned int) new_argc + 1));
346
if(plus_argv == NULL){
347
perror("realloc");
348
exitstatus = EXIT_FAILURE;
349
goto end;
350
}
351
plus_argv[new_argc-1] = arg;
352
plus_argv[new_argc] = NULL;
353
}
354
355
ret = argp_parse (&argp, new_argc, plus_argv, 0, 0, &plugin_list);
356
if (ret == ARGP_ERR_UNKNOWN){
357
fprintf(stderr, "Unknown error while parsing arguments\n");
358
exitstatus = EXIT_FAILURE;
359
goto end;
653
/* Parse using parse_opt_config_file() in order to get the custom
654
config file location, if any. */
655
ret = argp_parse(&argp, argc, argv,
656
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
657
NULL, NULL);
658
switch(ret){
659
case 0:
660
break;
661
case ENOMEM:
662
default:
663
errno = ret;
664
error(0, errno, "argp_parse");
665
exitstatus = EX_OSERR;
666
goto fallback;
667
case EINVAL:
668
exitstatus = EX_USAGE;
669
goto fallback;
670
}
671
672
/* Reset to the normal argument parser */
673
argp.parser = parse_opt;
674
675
/* Open the configfile if available */
676
if(argfile == NULL){
677
conffp = fopen(AFILE, "r");
678
} else {
679
conffp = fopen(argfile, "r");
680
}
681
if(conffp != NULL){
682
char *org_line = NULL;
683
char *p, *arg, *new_arg, *line;
684
size_t size = 0;
685
const char whitespace_delims[] = " \r\t\f\v\n";
686
const char comment_delim[] = "#";
687
688
custom_argc = 1;
689
custom_argv = malloc(sizeof(char*) * 2);
690
if(custom_argv == NULL){
691
error(0, errno, "malloc");
692
exitstatus = EX_OSERR;
693
goto fallback;
694
}
695
custom_argv[0] = argv[0];
696
custom_argv[1] = NULL;
697
698
/* for each line in the config file, strip whitespace and ignore
699
commented text */
700
while(true){
701
sret = getline(&org_line, &size, conffp);
702
if(sret == -1){
703
break;
704
}
705
706
line = org_line;
707
arg = strsep(&line, comment_delim);
708
while((p = strsep(&arg, whitespace_delims)) != NULL){
709
if(p[0] == '\0'){
710
continue;
711
}
712
new_arg = strdup(p);
713
if(new_arg == NULL){
714
error(0, errno, "strdup");
715
exitstatus = EX_OSERR;
716
free(org_line);
717
goto fallback;
718
}
719
720
custom_argc += 1;
721
{
722
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
723
char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
724
sizeof(char *));
725
#else
726
char **new_argv = NULL;
727
if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
728
/* overflow */
729
errno = ENOMEM;
730
} else {
731
new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
732
* sizeof(char *));
733
}
734
#endif
735
if(new_argv == NULL){
736
error(0, errno, "reallocarray");
737
exitstatus = EX_OSERR;
738
free(new_arg);
739
free(org_line);
740
goto fallback;
741
} else {
742
custom_argv = new_argv;
743
}
744
}
745
custom_argv[custom_argc-1] = new_arg;
746
custom_argv[custom_argc] = NULL;
747
}
748
}
749
do {
750
ret = fclose(conffp);
751
} while(ret == EOF and errno == EINTR);
752
if(ret == EOF){
753
error(0, errno, "fclose");
754
exitstatus = EX_IOERR;
755
goto fallback;
756
}
757
free(org_line);
758
} else {
759
/* Check for harmful errors and go to fallback. Other errors might
760
not affect opening plugins */
761
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
762
error(0, errno, "fopen");
763
exitstatus = EX_OSERR;
764
goto fallback;
765
}
766
}
767
/* If there were any arguments from the configuration file, pass
768
them to parser as command line arguments */
769
if(custom_argv != NULL){
770
ret = argp_parse(&argp, custom_argc, custom_argv,
771
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
772
NULL, NULL);
773
switch(ret){
774
case 0:
775
break;
776
case ENOMEM:
777
default:
778
errno = ret;
779
error(0, errno, "argp_parse");
780
exitstatus = EX_OSERR;
781
goto fallback;
782
case EINVAL:
783
exitstatus = EX_CONFIG;
784
goto fallback;
785
}
786
}
787
788
/* Parse actual command line arguments, to let them override the
789
config file */
790
ret = argp_parse(&argp, argc, argv,
791
ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
792
NULL, NULL);
793
switch(ret){
794
case 0:
795
break;
796
case ENOMEM:
797
default:
798
errno = ret;
799
error(0, errno, "argp_parse");
800
exitstatus = EX_OSERR;
801
goto fallback;
802
case EINVAL:
803
exitstatus = EX_USAGE;
804
goto fallback;
805
}
806
807
{
808
char *pluginhelperenv;
809
bool bret = true;
810
ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
811
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
812
if(ret != -1){
813
bret = add_environment(getplugin(NULL), pluginhelperenv, true);
814
}
815
if(ret == -1 or not bret){
816
error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
817
" environment variable to \"%s\" for all plugins\n",
818
pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
819
}
820
if(ret != -1){
821
free(pluginhelperenv);
360
822
}
361
823
}
362
824
363
825
if(debug){
364
for(plugin *p = plugin_list; p != NULL; p=p->next){
826
for(plugin *p = plugin_list; p != NULL; p = p->next){
365
827
fprintf(stderr, "Plugin: %s has %d arguments\n",
366
828
p->name ? p->name : "Global", p->argc - 1);
367
829
for(char **a = p->argv; *a != NULL; a++){
368
830
fprintf(stderr, "\tArg: %s\n", *a);
369
831
}
370
}
371
}
372
832
fprintf(stderr, "...and %d environment variables\n", p->envc);
833
for(char **a = p->environ; *a != NULL; a++){
834
fprintf(stderr, "\t%s\n", *a);
835
}
836
}
837
}
838
839
if(getuid() == 0){
840
/* Work around Debian bug #633582:
841
<https://bugs.debian.org/633582> */
842
int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
843
if(plugindir_fd == -1){
844
if(errno != ENOENT){
845
error(0, errno, "open(\"" PDIR "\")");
846
}
847
} else {
848
ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
849
if(ret == -1){
850
error(0, errno, "fstat");
851
} else {
852
if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
853
ret = fchown(plugindir_fd, uid, gid);
854
if(ret == -1){
855
error(0, errno, "fchown");
856
}
857
}
858
}
859
close(plugindir_fd);
860
}
861
862
/* Work around Debian bug #981302
863
<https://bugs.debian.org/981302> */
864
if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
865
ret = symlink("/proc/self/fd", "/dev/fd");
866
if(ret == -1){
867
error(0, errno, "Failed to create /dev/fd symlink");
868
}
869
}
870
}
871
872
/* Lower permissions */
873
ret = setgid(gid);
874
if(ret == -1){
875
error(0, errno, "setgid");
876
}
373
877
ret = setuid(uid);
374
if (ret == -1){
375
perror("setuid");
376
}
377
378
setgid(gid);
379
if (ret == -1){
380
perror("setgid");
381
}
382
383
dir = opendir(plugindir);
384
if(dir == NULL){
385
perror("Could not open plugin dir");
386
exitstatus = EXIT_FAILURE;
387
goto end;
388
}
389
390
/* Set the FD_CLOEXEC flag on the directory, if possible */
878
if(ret == -1){
879
error(0, errno, "setuid");
880
}
881
882
/* Open plugin directory with close_on_exec flag */
391
883
{
392
int dir_fd = dirfd(dir);
393
if(dir_fd >= 0){
394
ret = set_cloexec_flag(dir_fd);
395
if(ret < 0){
396
perror("set_cloexec_flag");
397
exitstatus = EXIT_FAILURE;
398
goto end;
884
dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
885
#ifdef O_CLOEXEC
886
O_CLOEXEC
887
#else /* not O_CLOEXEC */
888
0
889
#endif /* not O_CLOEXEC */
890
);
891
if(dir_fd == -1){
892
error(0, errno, "Could not open plugin dir");
893
exitstatus = EX_UNAVAILABLE;
894
goto fallback;
895
}
896
897
#ifndef O_CLOEXEC
898
/* Set the FD_CLOEXEC flag on the directory */
899
ret = set_cloexec_flag(dir_fd);
900
if(ret < 0){
901
error(0, errno, "set_cloexec_flag");
902
exitstatus = EX_OSERR;
903
goto fallback;
904
}
905
#endif /* O_CLOEXEC */
906
}
907
908
int good_name(const struct dirent * const dirent){
909
const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
910
"*.dpkg-old", "*.dpkg-bak",
911
"*.dpkg-divert", NULL };
912
#ifdef __GNUC__
913
#pragma GCC diagnostic push
914
#pragma GCC diagnostic ignored "-Wcast-qual"
915
#endif
916
for(const char **pat = (const char **)patterns;
917
*pat != NULL; pat++){
918
#ifdef __GNUC__
919
#pragma GCC diagnostic pop
920
#endif
921
if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
922
!= FNM_NOMATCH){
923
if(debug){
924
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
925
" matching pattern %s\n", dirent->d_name, *pat);
926
}
927
return 0;
399
928
}
400
929
}
930
return 1;
931
}
932
933
int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
934
alphasort);
935
if(numplugins == -1){
936
error(0, errno, "Could not scan plugin dir");
937
direntries = NULL;
938
exitstatus = EX_OSERR;
939
goto fallback;
401
940
}
402
941
403
942
FD_ZERO(&rfds_all);
404
943
405
while(true){
406
dirst = readdir(dir);
407
408
// All directory entries have been processed
409
if(dirst == NULL){
410
if (errno == EBADF){
411
perror("readdir");
412
exitstatus = EXIT_FAILURE;
413
goto end;
414
}
415
break;
416
}
417
418
d_name_len = strlen(dirst->d_name);
419
420
// Ignore dotfiles, backup files and other junk
421
{
422
bool bad_name = false;
423
424
const char const *bad_prefixes[] = { ".", "#", NULL };
425
426
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
427
".dpkg-old",
428
".dpkg-divert", NULL };
429
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
430
size_t pre_len = strlen(*pre);
431
if((d_name_len >= pre_len)
432
and strncmp((dirst->d_name), *pre, pre_len) == 0){
433
if(debug){
434
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
435
" with bad prefix %s\n", dirst->d_name, *pre);
436
}
437
bad_name = true;
438
break;
439
}
440
}
441
442
if(bad_name){
443
continue;
444
}
445
446
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
447
size_t suf_len = strlen(*suf);
448
if((d_name_len >= suf_len)
449
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
450
== 0)){
451
if(debug){
452
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
453
" with bad suffix %s\n", dirst->d_name, *suf);
454
}
455
bad_name = true;
456
break;
457
}
458
}
459
460
if(bad_name){
461
continue;
462
}
463
}
464
465
char *filename = malloc(d_name_len + strlen(plugindir) + 2);
466
if (filename == NULL){
467
perror("malloc");
468
continue;
469
}
470
strcpy(filename, plugindir); /* Spurious warning */
471
strcat(filename, "/"); /* Spurious warning */
472
strcat(filename, dirst->d_name); /* Spurious warning */
473
474
ret = stat(filename, &st);
475
if (ret == -1){
476
perror("stat");
477
free(filename);
478
continue;
479
}
480
481
if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
944
/* Read and execute any executable in the plugin directory*/
945
for(int i = 0; i < numplugins; i++){
946
947
int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
948
if(plugin_fd == -1){
949
error(0, errno, "Could not open plugin");
950
free(direntries[i]);
951
continue;
952
}
953
ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
954
if(ret == -1){
955
error(0, errno, "stat");
956
close(plugin_fd);
957
free(direntries[i]);
958
continue;
959
}
960
961
/* Ignore non-executable files */
962
if(not S_ISREG(st.st_mode)
963
or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
964
X_OK, 0)) != 0)){
482
965
if(debug){
483
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
484
" with bad type or mode\n", filename);
966
fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
967
" with bad type or mode\n",
968
plugindir != NULL ? plugindir : PDIR,
969
direntries[i]->d_name);
485
970
}
486
free(filename);
487
continue;
488
}
489
if(getplugin(dirst->d_name, &plugin_list)->disabled){
971
close(plugin_fd);
972
free(direntries[i]);
973
continue;
974
}
975
976
plugin *p = getplugin(direntries[i]->d_name);
977
if(p == NULL){
978
error(0, errno, "getplugin");
979
close(plugin_fd);
980
free(direntries[i]);
981
continue;
982
}
983
if(p->disabled){
490
984
if(debug){
491
985
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
492
dirst->d_name);
986
direntries[i]->d_name);
493
987
}
494
free(filename);
988
close(plugin_fd);
989
free(direntries[i]);
495
990
continue;
496
991
}
497
plugin *p = getplugin(dirst->d_name, &plugin_list);
498
992
{
499
993
/* Add global arguments to argument list for this plugin */
500
plugin *g = getplugin(NULL, &plugin_list);
501
for(char **a = g->argv + 1; *a != NULL; a++){
502
addargument(p, *a);
503
}
504
}
505
int pipefd[2];
506
ret = pipe(pipefd);
507
if (ret == -1){
508
perror("pipe");
509
exitstatus = EXIT_FAILURE;
510
goto end;
511
}
994
plugin *g = getplugin(NULL);
995
if(g != NULL){
996
for(char **a = g->argv + 1; *a != NULL; a++){
997
if(not add_argument(p, *a)){
998
error(0, errno, "add_argument");
999
}
1000
}
1001
/* Add global environment variables */
1002
for(char **e = g->environ; *e != NULL; e++){
1003
if(not add_environment(p, *e, false)){
1004
error(0, errno, "add_environment");
1005
}
1006
}
1007
}
1008
}
1009
/* If this plugin has any environment variables, we need to
1010
duplicate the environment from this process, too. */
1011
if(p->environ[0] != NULL){
1012
for(char **e = environ; *e != NULL; e++){
1013
if(not add_environment(p, *e, false)){
1014
error(0, errno, "add_environment");
1015
}
1016
}
1017
}
1018
1019
int pipefd[2];
1020
#ifndef O_CLOEXEC
1021
ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
1022
#else /* O_CLOEXEC */
1023
ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
1024
#endif /* O_CLOEXEC */
1025
if(ret == -1){
1026
error(0, errno, "pipe");
1027
exitstatus = EX_OSERR;
1028
free(direntries[i]);
1029
goto fallback;
1030
}
1031
if(pipefd[0] >= FD_SETSIZE){
1032
fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
1033
FD_SETSIZE);
1034
close(pipefd[0]);
1035
close(pipefd[1]);
1036
exitstatus = EX_OSERR;
1037
free(direntries[i]);
1038
goto fallback;
1039
}
1040
#ifndef O_CLOEXEC
1041
/* Ask OS to automatic close the pipe on exec */
512
1042
ret = set_cloexec_flag(pipefd[0]);
513
1043
if(ret < 0){
514
perror("set_cloexec_flag");
515
exitstatus = EXIT_FAILURE;
516
goto end;
1044
error(0, errno, "set_cloexec_flag");
1045
close(pipefd[0]);
1046
close(pipefd[1]);
1047
exitstatus = EX_OSERR;
1048
free(direntries[i]);
1049
goto fallback;
517
1050
}
518
1051
ret = set_cloexec_flag(pipefd[1]);
519
1052
if(ret < 0){
520
perror("set_cloexec_flag");
521
exitstatus = EXIT_FAILURE;
522
goto end;
1053
error(0, errno, "set_cloexec_flag");
1054
close(pipefd[0]);
1055
close(pipefd[1]);
1056
exitstatus = EX_OSERR;
1057
free(direntries[i]);
1058
goto fallback;
523
1059
}
1060
#endif /* not O_CLOEXEC */
524
1061
/* Block SIGCHLD until process is safely in process list */
525
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1062
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
1063
&sigchld_action.sa_mask,
1064
NULL));
526
1065
if(ret < 0){
527
perror("sigprocmask");
528
exitstatus = EXIT_FAILURE;
529
goto end;
1066
error(0, errno, "sigprocmask");
1067
exitstatus = EX_OSERR;
1068
free(direntries[i]);
1069
goto fallback;
530
1070
}
531
// Starting a new process to be watched
532
pid_t pid = fork();
1071
/* Starting a new process to be watched */
1072
pid_t pid;
1073
do {
1074
pid = fork();
1075
} while(pid == -1 and errno == EINTR);
533
1076
if(pid == -1){
534
perror("fork");
535
exitstatus = EXIT_FAILURE;
536
goto end;
1077
error(0, errno, "fork");
1078
TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1079
&sigchld_action.sa_mask, NULL));
1080
close(pipefd[0]);
1081
close(pipefd[1]);
1082
exitstatus = EX_OSERR;
1083
free(direntries[i]);
1084
goto fallback;
537
1085
}
538
1086
if(pid == 0){
539
1087
/* this is the child process */
540
1088
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
541
1089
if(ret < 0){
542
perror("sigaction");
543
_exit(EXIT_FAILURE);
1090
error(0, errno, "sigaction");
1091
_exit(EX_OSERR);
544
1092
}
545
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1093
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
546
1094
if(ret < 0){
547
perror("sigprocmask");
548
_exit(EXIT_FAILURE);
1095
error(0, errno, "sigprocmask");
1096
_exit(EX_OSERR);
549
1097
}
550
1098
551
1099
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
552
1100
if(ret == -1){
553
perror("dup2");
554
_exit(EXIT_FAILURE);
1101
error(0, errno, "dup2");
1102
_exit(EX_OSERR);
555
1103
}
556
1104
557
if(dirfd(dir) < 0){
558
/* If dir has no file descriptor, we could not set FD_CLOEXEC
559
above and must now close it manually here. */
560
closedir(dir);
561
}
562
if(execv(filename, p->argv) < 0){
563
perror("execv");
564
_exit(EXIT_FAILURE);
1105
if(fexecve(plugin_fd, p->argv,
1106
(p->environ[0] != NULL) ? p->environ : environ) < 0){
1107
error(0, errno, "fexecve for %s/%s",
1108
plugindir != NULL ? plugindir : PDIR,
1109
direntries[i]->d_name);
1110
_exit(EX_OSERR);
565
1111
}
566
1112
/* no return */
567
1113
}
568
/* parent process */
569
free(filename);
570
close(pipefd[1]); /* close unused write end of pipe */
571
process *new_process = malloc(sizeof(process));
572
if (new_process == NULL){
573
perror("malloc");
574
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1114
/* Parent process */
1115
close(pipefd[1]); /* Close unused write end of pipe */
1116
close(plugin_fd);
1117
plugin *new_plugin = getplugin(direntries[i]->d_name);
1118
if(new_plugin == NULL){
1119
error(0, errno, "getplugin");
1120
ret = (int)(TEMP_FAILURE_RETRY
1121
(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1122
NULL)));
575
1123
if(ret < 0){
576
perror("sigprocmask");
1124
error(0, errno, "sigprocmask");
577
1125
}
578
exitstatus = EXIT_FAILURE;
579
goto end;
1126
exitstatus = EX_OSERR;
1127
free(direntries[i]);
1128
goto fallback;
580
1129
}
1130
free(direntries[i]);
581
1131
582
*new_process = (struct process){ .pid = pid,
583
.fd = pipefd[0],
584
.next = process_list };
585
// List handling
586
process_list = new_process;
1132
new_plugin->pid = pid;
1133
new_plugin->fd = pipefd[0];
1134
1135
if(debug){
1136
fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1137
new_plugin->name, (intmax_t) (new_plugin->pid));
1138
}
1139
587
1140
/* Unblock SIGCHLD so signal handler can be run if this process
588
1141
has already completed */
589
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1142
ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1143
&sigchld_action.sa_mask,
1144
NULL));
590
1145
if(ret < 0){
591
perror("sigprocmask");
592
exitstatus = EXIT_FAILURE;
593
goto end;
594
}
595
596
FD_SET(new_process->fd, &rfds_all);
597
598
if (maxfd < new_process->fd){
599
maxfd = new_process->fd;
600
}
601
602
}
603
604
/* Free the plugin list */
605
for(plugin *next; plugin_list != NULL; plugin_list = next){
606
next = plugin_list->next;
607
free(plugin_list->argv);
608
free(plugin_list);
609
}
610
611
closedir(dir);
612
dir = NULL;
613
614
if (process_list == NULL){
615
fprintf(stderr, "No plugin processes started. Incorrect plugin"
616
" directory?\n");
617
process_list = NULL;
618
}
619
while(process_list){
1146
error(0, errno, "sigprocmask");
1147
exitstatus = EX_OSERR;
1148
goto fallback;
1149
}
1150
1151
FD_SET(new_plugin->fd, &rfds_all);
1152
1153
if(maxfd < new_plugin->fd){
1154
maxfd = new_plugin->fd;
1155
}
1156
}
1157
1158
free(direntries);
1159
direntries = NULL;
1160
close(dir_fd);
1161
dir_fd = -1;
1162
free_plugin(getplugin(NULL));
1163
1164
for(plugin *p = plugin_list; p != NULL; p = p->next){
1165
if(p->pid != 0){
1166
break;
1167
}
1168
if(p->next == NULL){
1169
fprintf(stderr, "No plugin processes started. Incorrect plugin"
1170
" directory?\n");
1171
free_plugin_list();
1172
}
1173
}
1174
1175
/* Main loop while running plugins exist */
1176
while(plugin_list){
620
1177
fd_set rfds = rfds_all;
621
1178
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
622
if (select_ret == -1){
623
perror("select");
624
exitstatus = EXIT_FAILURE;
625
goto end;
1179
if(select_ret == -1 and errno != EINTR){
1180
error(0, errno, "select");
1181
exitstatus = EX_OSERR;
1182
goto fallback;
626
1183
}
627
1184
/* OK, now either a process completed, or something can be read
628
1185
from one of them */
629
for(process *proc = process_list; proc ; proc = proc->next){
1186
for(plugin *proc = plugin_list; proc != NULL;){
630
1187
/* Is this process completely done? */
631
if(proc->eof and proc->completed){
1188
if(proc->completed and proc->eof){
632
1189
/* Only accept the plugin output if it exited cleanly */
633
1190
if(not WIFEXITED(proc->status)
634
1191
or WEXITSTATUS(proc->status) != 0){
635
1192
/* Bad exit by plugin */
1193
636
1194
if(debug){
637
1195
if(WIFEXITED(proc->status)){
638
fprintf(stderr, "Plugin %u exited with status %d\n",
639
(unsigned int) (proc->pid),
1196
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1197
" status %d\n", proc->name,
1198
(intmax_t) (proc->pid),
640
1199
WEXITSTATUS(proc->status));
641
} else if(WIFSIGNALED(proc->status)) {
642
fprintf(stderr, "Plugin %u killed by signal %d\n",
643
(unsigned int) (proc->pid),
644
WTERMSIG(proc->status));
645
} else if(WCOREDUMP(proc->status)){
646
fprintf(stderr, "Plugin %d dumped core\n",
647
(unsigned int) (proc->pid));
1200
} else if(WIFSIGNALED(proc->status)){
1201
fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
1202
" signal %d: %s\n", proc->name,
1203
(intmax_t) (proc->pid),
1204
WTERMSIG(proc->status),
1205
strsignal(WTERMSIG(proc->status)));
648
1206
}
649
1207
}
1208
650
1209
/* Remove the plugin */
651
1210
FD_CLR(proc->fd, &rfds_all);
1211
652
1212
/* Block signal while modifying process_list */
653
ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
1213
ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1214
(SIG_BLOCK,
1215
&sigchld_action.sa_mask,
1216
NULL));
654
1217
if(ret < 0){
655
perror("sigprocmask");
656
exitstatus = EXIT_FAILURE;
657
goto end;
658
}
659
/* Delete this process entry from the list */
660
if(process_list == proc){
661
/* First one - simple */
662
process_list = proc->next;
663
} else {
664
/* Second one or later */
665
for(process *p = process_list; p != NULL; p = p->next){
666
if(p->next == proc){
667
p->next = proc->next;
668
break;
669
}
670
}
671
}
1218
error(0, errno, "sigprocmask");
1219
exitstatus = EX_OSERR;
1220
goto fallback;
1221
}
1222
1223
plugin *next_plugin = proc->next;
1224
free_plugin(proc);
1225
proc = next_plugin;
1226
672
1227
/* We are done modifying process list, so unblock signal */
673
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
674
NULL);
1228
ret = (int)(TEMP_FAILURE_RETRY
1229
(sigprocmask(SIG_UNBLOCK,
1230
&sigchld_action.sa_mask, NULL)));
675
1231
if(ret < 0){
676
perror("sigprocmask");
677
}
678
free(proc->buffer);
679
free(proc);
680
/* We deleted this process from the list, so we can't go
681
proc->next. Therefore, start over from the beginning of
682
the process list */
683
break;
1232
error(0, errno, "sigprocmask");
1233
exitstatus = EX_OSERR;
1234
goto fallback;
1235
}
1236
1237
if(plugin_list == NULL){
1238
break;
1239
}
1240
1241
continue;
684
1242
}
1243
685
1244
/* This process exited nicely, so print its buffer */
686
687
bool bret = print_out_password(proc->buffer, proc->buffer_length);
1245
1246
bool bret = print_out_password(proc->buffer,
1247
proc->buffer_length);
688
1248
if(not bret){
689
perror("print_out_password");
690
exitstatus = EXIT_FAILURE;
1249
error(0, errno, "print_out_password");
1250
exitstatus = EX_IOERR;
691
1251
}
692
goto end;
1252
goto fallback;
693
1253
}
1254
694
1255
/* This process has not completed. Does it have any output? */
695
1256
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
696
1257
/* This process had nothing to say at this time */
1258
proc = proc->next;
697
1259
continue;
698
1260
}
699
1261
/* Before reading, make the process' data buffer large enough */
700
1262
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
701
proc->buffer = realloc(proc->buffer, proc->buffer_size
702
+ (size_t) BUFFER_SIZE);
703
if (proc->buffer == NULL){
704
perror("malloc");
705
exitstatus = EXIT_FAILURE;
706
goto end;
1263
char *new_buffer = realloc(proc->buffer, proc->buffer_size
1264
+ (size_t) BUFFER_SIZE);
1265
if(new_buffer == NULL){
1266
error(0, errno, "malloc");
1267
exitstatus = EX_OSERR;
1268
goto fallback;
707
1269
}
1270
proc->buffer = new_buffer;
708
1271
proc->buffer_size += BUFFER_SIZE;
709
1272
}
710
1273
/* Read from the process */
711
ret = read(proc->fd, proc->buffer + proc->buffer_length,
712
BUFFER_SIZE);
713
if(ret < 0){
1274
sret = TEMP_FAILURE_RETRY(read(proc->fd,
1275
proc->buffer
1276
+ proc->buffer_length,
1277
BUFFER_SIZE));
1278
if(sret < 0){
714
1279
/* Read error from this process; ignore the error */
1280
proc = proc->next;
715
1281
continue;
716
1282
}
717
if(ret == 0){
1283
if(sret == 0){
718
1284
/* got EOF */
719
1285
proc->eof = true;
720
1286
} else {
721
proc->buffer_length += (size_t) ret;
1287
proc->buffer_length += (size_t) sret;
722
1288
}
723
1289
}
724
1290
}
725
726
727
end:
728
729
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
730
/* Fallback if all plugins failed, none are found or an error occured */
1291
1292
1293
fallback:
1294
1295
if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
1296
and exitstatus != EX_OK)){
1297
/* Fallback if all plugins failed, none are found or an error
1298
occured */
731
1299
bool bret;
732
1300
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
733
1301
char *passwordbuffer = getpass("Password: ");
734
bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
1302
size_t len = strlen(passwordbuffer);
1303
/* Strip trailing newline */
1304
if(len > 0 and passwordbuffer[len-1] == '\n'){
1305
passwordbuffer[len-1] = '\0'; /* not strictly necessary */
1306
len--;
1307
}
1308
bret = print_out_password(passwordbuffer, len);
735
1309
if(not bret){
736
perror("print_out_password");
737
exitstatus = EXIT_FAILURE;
738
goto end;
1310
error(0, errno, "print_out_password");
1311
exitstatus = EX_IOERR;
739
1312
}
740
1313
}
741
1314
742
1315
/* Restore old signal handler */
743
sigaction(SIGCHLD, &old_sigchld_action, NULL);
744
745
free(plus_argv);
746
747
/* Free the plugin list */
748
for(plugin *next; plugin_list != NULL; plugin_list = next){
749
next = plugin_list->next;
750
free(plugin_list->argv);
751
free(plugin_list);
752
}
753
754
if(dir != NULL){
755
closedir(dir);
756
}
757
758
/* Free the process list and kill the processes */
759
for(process *next; process_list != NULL; process_list = next){
760
next = process_list->next;
761
close(process_list->fd);
762
ret = kill(process_list->pid, SIGTERM);
763
if(ret == -1 and errno != ESRCH){
764
/* set-uid proccesses migth not get closed */
765
perror("kill");
766
}
767
free(process_list->buffer);
768
free(process_list);
1316
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1317
if(ret == -1){
1318
error(0, errno, "sigaction");
1319
exitstatus = EX_OSERR;
1320
}
1321
1322
if(custom_argv != NULL){
1323
for(char **arg = custom_argv+1; *arg != NULL; arg++){
1324
free(*arg);
1325
}
1326
free(custom_argv);
1327
}
1328
1329
free(direntries);
1330
1331
if(dir_fd != -1){
1332
close(dir_fd);
1333
}
1334
1335
/* Kill the processes */
1336
for(plugin *p = plugin_list; p != NULL; p = p->next){
1337
if(p->pid != 0){
1338
close(p->fd);
1339
ret = kill(p->pid, SIGTERM);
1340
if(ret == -1 and errno != ESRCH){
1341
/* Set-uid proccesses might not get closed */
1342
error(0, errno, "kill");
1343
}
1344
}
769
1345
}
770
1346
771
1347
/* Wait for any remaining child processes to terminate */
772
do{
1348
do {
773
1349
ret = wait(NULL);
774
1350
} while(ret >= 0);
775
1351
if(errno != ECHILD){
776
perror("wait");
1352
error(0, errno, "wait");
777
1353
}
778
1354
1355
free_plugin_list();
1356
1357
free(plugindir);
1358
free(pluginhelperdir);
1359
free(argfile);
1360
779
1361
return exitstatus;
780
1362
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0