To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugin-runner.c
- browse files at revision 1232
- compare with another revision
- download diff
- download tarball
- view history from revision 1232
- Committer: Teddy Hogeborn
- Date: 2021-02-01 19:30:45 UTC
- 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
26
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),
25
asprintf() */
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(), asprintf() */
53
FD_CLOEXEC, openat(), scandirat(),
54
pipe2() */
55
#include <string.h> /* strsep, strlen(), strsignal(),
56
strcmp(), strncmp() */
55
57
#include <errno.h> /* errno */
56
58
#include <argp.h> /* struct argp_option, struct
57
59
argp_state, struct argp,
58
60
argp_parse(), ARGP_ERR_UNKNOWN,
59
ARGP_KEY_END, ARGP_KEY_ARG, error_t */
61
ARGP_KEY_END, ARGP_KEY_ARG,
62
error_t */
60
63
#include <signal.h> /* struct sigaction, sigemptyset(),
61
64
sigaddset(), sigaction(),
62
65
sigprocmask(), SIG_BLOCK, SIGCHLD,
63
SIG_UNBLOCK, kill() */
66
SIG_UNBLOCK, kill(), sig_atomic_t
67
*/
64
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() */
65
75
66
76
#define BUFFER_SIZE 256
67
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
68
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{
75
pid_t pid;
76
int fd;
77
char *buffer;
78
size_t buffer_size;
79
size_t buffer_length;
80
bool eof;
81
bool completed;
82
int status;
83
struct process *next;
84
} process;
77
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>";
85
84
86
85
typedef struct plugin{
87
86
char *name; /* can be NULL or any plugin name */
90
89
char **environ;
91
90
int envc;
92
91
bool disabled;
92
93
/* Variables used for running processes*/
94
pid_t pid;
95
int fd;
96
char *buffer;
97
size_t buffer_size;
98
size_t buffer_length;
99
bool eof;
100
volatile sig_atomic_t completed;
101
int status;
93
102
struct plugin *next;
94
103
} plugin;
95
104
96
static plugin *getplugin(char *name, plugin **plugin_list){
97
for (plugin *p = *plugin_list; p != NULL; p = p->next){
98
if ((p->name == name)
99
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))){
100
115
return p;
101
116
}
102
117
}
103
118
/* Create a new plugin */
104
plugin *new_plugin = malloc(sizeof(plugin));
105
if (new_plugin == NULL){
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){
106
124
return NULL;
107
125
}
108
*new_plugin = (plugin) { .name = name,
109
.argc = 1,
110
.envc = 0,
111
.disabled = false,
112
.next = *plugin_list };
113
114
new_plugin->argv = malloc(sizeof(char *) * 2);
115
if (new_plugin->argv == NULL){
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);
116
150
free(new_plugin);
151
errno = e;
117
152
return NULL;
118
153
}
119
new_plugin->argv[0] = name;
154
new_plugin->argv[0] = copy_name;
120
155
new_plugin->argv[1] = NULL;
121
122
new_plugin->environ = malloc(sizeof(char *));
156
157
do {
158
new_plugin->environ = malloc(sizeof(char *));
159
} while(new_plugin->environ == NULL and errno == EINTR);
123
160
if(new_plugin->environ == NULL){
161
int e = errno;
162
free(copy_name);
124
163
free(new_plugin->argv);
125
164
free(new_plugin);
165
errno = e;
126
166
return NULL;
127
167
}
128
168
new_plugin->environ[0] = NULL;
169
129
170
/* Append the new plugin to the list */
130
*plugin_list = new_plugin;
171
plugin_list = new_plugin;
131
172
return new_plugin;
132
173
}
133
174
134
175
/* Helper function for add_argument and add_environment */
176
__attribute__((nonnull, warn_unused_result))
135
177
static bool add_to_char_array(const char *new, char ***array,
136
178
int *len){
137
179
/* Resize the pointed-to array to hold one more pointer */
138
*array = realloc(*array, sizeof(char *)
139
* (size_t) ((*len) + 2));
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);
140
196
/* Malloc check */
141
if(*array == NULL){
197
if(new_array == NULL){
142
198
return false;
143
199
}
200
*array = new_array;
144
201
/* Make a copy of the new string */
145
char *copy = strdup(new);
202
char *copy;
203
do {
204
copy = strdup(new);
205
} while(copy == NULL and errno == EINTR);
146
206
if(copy == NULL){
147
207
return false;
148
208
}
155
215
}
156
216
157
217
/* Add to a plugin's argument vector */
218
__attribute__((nonnull(2), warn_unused_result))
158
219
static bool add_argument(plugin *p, const char *arg){
159
220
if(p == NULL){
160
221
return false;
163
224
}
164
225
165
226
/* Add to a plugin's environment */
166
static bool add_environment(plugin *p, const char *def){
227
__attribute__((nonnull(2), warn_unused_result))
228
static bool add_environment(plugin *p, const char *def, bool replace){
167
229
if(p == NULL){
168
230
return false;
169
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
}
170
252
return add_to_char_array(def, &(p->environ), &(p->envc));
171
253
}
172
254
173
255
#ifndef O_CLOEXEC
174
256
/*
175
257
* Based on the example in the GNU LibC manual chapter 13.13 "File
176
258
* Descriptor Flags".
177
* *Note File Descriptor Flags:(libc)Descriptor Flags.
259
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
178
260
*/
179
static int set_cloexec_flag(int fd)
180
{
181
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));
182
264
/* If reading the flags failed, return error indication now. */
183
265
if(ret < 0){
184
266
return ret;
185
267
}
186
268
/* Store modified flag word in the descriptor. */
187
return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
269
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
270
ret | FD_CLOEXEC));
188
271
}
189
190
process *process_list = NULL;
191
192
/* 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
193
276
status. */
194
void handle_sigchld(__attribute__((unused)) int sig){
195
process *proc = process_list;
196
int status;
197
pid_t pid = wait(&status);
198
if(pid == -1){
199
perror("wait");
200
return;
201
}
202
while(proc != NULL and proc->pid != pid){
203
proc = proc->next;
204
}
205
if(proc == NULL){
206
/* Process not found in process list */
207
return;
208
}
209
proc->status = status;
210
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;
211
307
}
212
308
213
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){
214
312
ssize_t ret;
215
if(length>0 and buffer[length-1] == '\n'){
216
length--;
217
}
218
313
for(size_t written = 0; written < length; written += (size_t)ret){
219
314
ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
220
315
length - written));
225
320
return true;
226
321
}
227
322
228
char **add_to_argv(char **argv, int *argc, char *arg){
229
if (argv == NULL){
230
*argc = 1;
231
argv = malloc(sizeof(char*) * 2);
232
if(argv == NULL){
233
return NULL;
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
}
234
349
}
235
argv[0] = NULL; /* Will be set to argv[0] in main before parsing */
236
argv[1] = NULL;
237
}
238
*argc += 1;
239
argv = realloc(argv, sizeof(char *)
240
* ((unsigned int) *argc + 1));
241
if(argv == NULL){
242
return NULL;
243
}
244
argv[*argc-1] = arg;
245
argv[*argc] = NULL;
246
return argv;
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
}
247
359
}
248
360
249
361
int main(int argc, char *argv[]){
250
const char *plugindir = "/lib/mandos/plugins.d";
251
const char *argfile = ARGFILE;
362
char *plugindir = NULL;
363
char *pluginhelperdir = NULL;
364
char *argfile = NULL;
252
365
FILE *conffp;
253
size_t d_name_len;
254
DIR *dir = NULL;
255
struct dirent *dirst;
366
struct dirent **direntries = NULL;
256
367
struct stat st;
257
368
fd_set rfds_all;
258
369
int ret, maxfd = 0;
370
ssize_t sret;
259
371
uid_t uid = 65534;
260
372
gid_t gid = 65534;
261
373
bool debug = false;
265
377
.sa_flags = SA_NOCLDSTOP };
266
378
char **custom_argv = NULL;
267
379
int custom_argc = 0;
380
int dir_fd = -1;
268
381
269
382
/* Establish a signal handler */
270
383
sigemptyset(&sigchld_action.sa_mask);
271
384
ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
272
if(ret < 0){
273
perror("sigaddset");
274
exit(EXIT_FAILURE);
385
if(ret == -1){
386
error(0, errno, "sigaddset");
387
exitstatus = EX_OSERR;
388
goto fallback;
275
389
}
276
390
ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
277
if(ret < 0){
278
perror("sigaction");
279
exit(EXIT_FAILURE);
391
if(ret == -1){
392
error(0, errno, "sigaction");
393
exitstatus = EX_OSERR;
394
goto fallback;
280
395
}
281
396
282
397
/* The options we understand. */
284
399
{ .name = "global-options", .key = 'g',
285
400
.arg = "OPTION[,OPTION[,...]]",
286
401
.doc = "Options passed to all plugins" },
287
{ .name = "global-envs", .key = 'e',
402
{ .name = "global-env", .key = 'G',
288
403
.arg = "VAR=value",
289
404
.doc = "Environment variable passed to all plugins" },
290
405
{ .name = "options-for", .key = 'o',
291
406
.arg = "PLUGIN:OPTION[,OPTION[,...]]",
292
407
.doc = "Options passed only to specified plugin" },
293
{ .name = "envs-for", .key = 'f',
408
{ .name = "env-for", .key = 'E',
294
409
.arg = "PLUGIN:ENV=value",
295
410
.doc = "Environment variable passed to specified plugin" },
296
411
{ .name = "disable", .key = 'd',
297
412
.arg = "PLUGIN",
298
413
.doc = "Disable a specific plugin", .group = 1 },
414
{ .name = "enable", .key = 'e',
415
.arg = "PLUGIN",
416
.doc = "Enable a specific plugin", .group = 1 },
299
417
{ .name = "plugin-dir", .key = 128,
300
418
.arg = "DIRECTORY",
301
419
.doc = "Specify a different plugin directory", .group = 2 },
302
{ .name = "userid", .key = 129,
303
.arg = "ID", .flags = 0,
304
.doc = "User ID the plugins will run as", .group = 2 },
305
{ .name = "groupid", .key = 130,
306
.arg = "ID", .flags = 0,
307
.doc = "Group ID the plugins will run as", .group = 2 },
308
{ .name = "debug", .key = 131,
309
.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 },
310
444
{ .name = NULL }
311
445
};
312
446
313
error_t parse_opt (int key, char *arg, struct argp_state *state) {
314
/* Get the INPUT argument from `argp_parse', which we know is a
315
pointer to our plugin list pointer. */
316
plugin **plugins = state->input;
317
switch (key) {
318
case 'g':
319
if (arg != NULL){
320
char *p;
321
while((p = strsep(&arg, ",")) != NULL){
322
if(p[0] == '\0'){
323
continue;
324
}
325
if(not add_argument(getplugin(NULL, plugins), p)){
326
perror("add_argument");
327
return ARGP_ERR_UNKNOWN;
328
}
329
}
330
}
331
break;
332
case 'e':
333
if(arg == NULL){
334
break;
335
}
336
{
337
char *envdef = strdup(arg);
338
if(envdef == NULL){
339
break;
340
}
341
if(not add_environment(getplugin(NULL, plugins), envdef)){
342
perror("add_environment");
343
}
344
}
345
break;
346
case 'o':
347
if (arg != NULL){
348
char *p_name = strsep(&arg, ":");
349
if(p_name[0] == '\0'){
350
break;
351
}
352
char *opt = strsep(&arg, ":");
353
if(opt[0] == '\0'){
354
break;
355
}
356
if(opt != NULL){
357
char *p;
358
while((p = strsep(&opt, ",")) != NULL){
359
if(p[0] == '\0'){
360
continue;
361
}
362
if(not add_argument(getplugin(p_name, plugins), p)){
363
perror("add_argument");
364
return ARGP_ERR_UNKNOWN;
365
}
366
}
367
}
368
}
369
break;
370
case 'f':
371
if(arg == NULL){
372
break;
373
}
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 */
374
494
{
375
495
char *envdef = strchr(arg, ':');
376
496
if(envdef == NULL){
377
break;
378
}
379
char *p_name = strndup(arg, (size_t) (envdef-arg));
380
if(p_name == NULL){
381
break;
382
}
497
argp_error(state, "No colon in \"%s\"", arg);
498
errno = EINVAL;
499
break;
500
}
501
*envdef = '\0';
383
502
envdef++;
384
if(not add_environment(getplugin(p_name, plugins), envdef)){
385
perror("add_environment");
386
}
387
}
388
break;
389
case 'd':
390
if (arg != NULL){
391
plugin *p = getplugin(arg, plugins);
392
if(p == NULL){
393
return ARGP_ERR_UNKNOWN;
394
}
395
p->disabled = true;
396
}
397
break;
398
case 128:
399
plugindir = arg;
400
break;
401
case 129:
402
uid = (uid_t)strtol(arg, NULL, 10);
403
break;
404
case 130:
405
gid = (gid_t)strtol(arg, NULL, 10);
406
break;
407
case 131:
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 */
408
564
debug = true;
409
565
break;
410
case ARGP_KEY_ARG:
411
fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
412
break;
413
case ARGP_KEY_END:
414
break;
415
default:
416
return ARGP_ERR_UNKNOWN;
417
}
418
return 0;
419
}
420
421
plugin *plugin_list = NULL;
422
423
struct argp argp = { .options = options, .parser = parse_opt,
424
.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 = "",
425
651
.doc = "Mandos plugin runner -- Run plugins" };
426
652
427
ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
428
if (ret == ARGP_ERR_UNKNOWN){
429
fprintf(stderr, "Unknown error while parsing arguments\n");
430
exitstatus = EXIT_FAILURE;
431
goto end;
432
}
433
434
conffp = fopen(argfile, "r");
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
}
435
681
if(conffp != NULL){
436
682
char *org_line = NULL;
683
char *p, *arg, *new_arg, *line;
437
684
size_t size = 0;
438
ssize_t sret;
439
char *p, *arg, *new_arg, *line;
440
685
const char whitespace_delims[] = " \r\t\f\v\n";
441
686
const char comment_delim[] = "#";
442
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 */
443
700
while(true){
444
701
sret = getline(&org_line, &size, conffp);
445
702
if(sret == -1){
446
703
break;
447
704
}
448
705
449
706
line = org_line;
450
707
arg = strsep(&line, comment_delim);
451
708
while((p = strsep(&arg, whitespace_delims)) != NULL){
453
710
continue;
454
711
}
455
712
new_arg = strdup(p);
456
custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);
457
if (custom_argv == NULL){
458
perror("add_to_argv");
459
exitstatus = EXIT_FAILURE;
460
goto end;
461
}
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;
462
747
}
463
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
}
464
757
free(org_line);
465
} else{
758
} else {
466
759
/* Check for harmful errors and go to fallback. Other errors might
467
760
not affect opening plugins */
468
if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
469
perror("fopen");
470
exitstatus = EXIT_FAILURE;
471
goto end;
761
if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
762
error(0, errno, "fopen");
763
exitstatus = EX_OSERR;
764
goto fallback;
472
765
}
473
766
}
474
767
/* If there were any arguments from the configuration file, pass
768
them to parser as command line arguments */
475
769
if(custom_argv != NULL){
476
custom_argv[0] = argv[0];
477
ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
478
if (ret == ARGP_ERR_UNKNOWN){
479
fprintf(stderr, "Unknown error while parsing arguments\n");
480
exitstatus = EXIT_FAILURE;
481
goto end;
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);
482
822
}
483
823
}
484
824
485
825
if(debug){
486
for(plugin *p = plugin_list; p != NULL; p=p->next){
826
for(plugin *p = plugin_list; p != NULL; p = p->next){
487
827
fprintf(stderr, "Plugin: %s has %d arguments\n",
488
828
p->name ? p->name : "Global", p->argc - 1);
489
829
for(char **a = p->argv; *a != NULL; a++){
490
830
fprintf(stderr, "\tArg: %s\n", *a);
491
831
}
492
fprintf(stderr, "...and %u environment variables\n", p->envc);
832
fprintf(stderr, "...and %d environment variables\n", p->envc);
493
833
for(char **a = p->environ; *a != NULL; a++){
494
834
fprintf(stderr, "\t%s\n", *a);
495
835
}
496
836
}
497
837
}
498
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
}
499
877
ret = setuid(uid);
500
if (ret == -1){
501
perror("setuid");
502
}
503
504
setgid(gid);
505
if (ret == -1){
506
perror("setgid");
507
}
508
509
dir = opendir(plugindir);
510
if(dir == NULL){
511
perror("Could not open plugin dir");
512
exitstatus = EXIT_FAILURE;
513
goto end;
514
}
515
516
/* 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 */
517
883
{
518
int dir_fd = dirfd(dir);
519
if(dir_fd >= 0){
520
ret = set_cloexec_flag(dir_fd);
521
if(ret < 0){
522
perror("set_cloexec_flag");
523
exitstatus = EXIT_FAILURE;
524
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;
525
928
}
526
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;
527
940
}
528
941
529
942
FD_ZERO(&rfds_all);
530
943
531
while(true){
532
dirst = readdir(dir);
533
534
// All directory entries have been processed
535
if(dirst == NULL){
536
if (errno == EBADF){
537
perror("readdir");
538
exitstatus = EXIT_FAILURE;
539
goto end;
540
}
541
break;
542
}
543
544
d_name_len = strlen(dirst->d_name);
545
546
// Ignore dotfiles, backup files and other junk
547
{
548
bool bad_name = false;
549
550
const char const *bad_prefixes[] = { ".", "#", NULL };
551
552
const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
553
".dpkg-old",
554
".dpkg-divert", NULL };
555
for(const char **pre = bad_prefixes; *pre != NULL; pre++){
556
size_t pre_len = strlen(*pre);
557
if((d_name_len >= pre_len)
558
and strncmp((dirst->d_name), *pre, pre_len) == 0){
559
if(debug){
560
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
561
" with bad prefix %s\n", dirst->d_name, *pre);
562
}
563
bad_name = true;
564
break;
565
}
566
}
567
568
if(bad_name){
569
continue;
570
}
571
572
for(const char **suf = bad_suffixes; *suf != NULL; suf++){
573
size_t suf_len = strlen(*suf);
574
if((d_name_len >= suf_len)
575
and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
576
== 0)){
577
if(debug){
578
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
579
" with bad suffix %s\n", dirst->d_name, *suf);
580
}
581
bad_name = true;
582
break;
583
}
584
}
585
586
if(bad_name){
587
continue;
588
}
589
}
590
591
char *filename;
592
ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
593
if(ret < 0){
594
perror("asprintf");
595
continue;
596
}
597
598
ret = stat(filename, &st);
599
if (ret == -1){
600
perror("stat");
601
free(filename);
602
continue;
603
}
604
605
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)){
606
965
if(debug){
607
fprintf(stderr, "Ignoring plugin dir entry \"%s\""
608
" 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);
609
970
}
610
free(filename);
971
close(plugin_fd);
972
free(direntries[i]);
611
973
continue;
612
974
}
613
plugin *p = getplugin(dirst->d_name, &plugin_list);
975
976
plugin *p = getplugin(direntries[i]->d_name);
614
977
if(p == NULL){
615
perror("getplugin");
616
free(filename);
978
error(0, errno, "getplugin");
979
close(plugin_fd);
980
free(direntries[i]);
617
981
continue;
618
982
}
619
983
if(p->disabled){
620
984
if(debug){
621
985
fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
622
dirst->d_name);
986
direntries[i]->d_name);
623
987
}
624
free(filename);
988
close(plugin_fd);
989
free(direntries[i]);
625
990
continue;
626
991
}
627
992
{
628
993
/* Add global arguments to argument list for this plugin */
629
plugin *g = getplugin(NULL, &plugin_list);
994
plugin *g = getplugin(NULL);
630
995
if(g != NULL){
631
996
for(char **a = g->argv + 1; *a != NULL; a++){
632
997
if(not add_argument(p, *a)){
633
perror("add_argument");
998
error(0, errno, "add_argument");
634
999
}
635
1000
}
636
1001
/* Add global environment variables */
637
1002
for(char **e = g->environ; *e != NULL; e++){
638
if(not add_environment(p, *e)){
639
perror("add_environment");
1003
if(not add_environment(p, *e, false)){
1004
error(0, errno, "add_environment");
640
1005
}
641
1006
}
642
1007
}
643
1008
}
644
/* If this plugin has any environment variables, we will call
645
using execve and need to duplicate the environment from this
646
process, too. */
1009
/* If this plugin has any environment variables, we need to
1010
duplicate the environment from this process, too. */
647
1011
if(p->environ[0] != NULL){
648
1012
for(char **e = environ; *e != NULL; e++){
649
char *copy = strdup(*e);
650
if(copy == NULL){
651
perror("strdup");
652
continue;
653
}
654
if(not add_environment(p, copy)){
655
perror("add_environment");
1013
if(not add_environment(p, *e, false)){
1014
error(0, errno, "add_environment");
656
1015
}
657
1016
}
658
1017
}
659
1018
660
int pipefd[2];
661
ret = pipe(pipefd);
662
if (ret == -1){
663
perror("pipe");
664
exitstatus = EXIT_FAILURE;
665
goto end;
666
}
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 */
667
1042
ret = set_cloexec_flag(pipefd[0]);
668
1043
if(ret < 0){
669
perror("set_cloexec_flag");
670
exitstatus = EXIT_FAILURE;
671
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;
672
1050
}
673
1051
ret = set_cloexec_flag(pipefd[1]);
674
1052
if(ret < 0){
675
perror("set_cloexec_flag");
676
exitstatus = EXIT_FAILURE;
677
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;
678
1059
}
1060
#endif /* not O_CLOEXEC */
679
1061
/* Block SIGCHLD until process is safely in process list */
680
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));
681
1065
if(ret < 0){
682
perror("sigprocmask");
683
exitstatus = EXIT_FAILURE;
684
goto end;
1066
error(0, errno, "sigprocmask");
1067
exitstatus = EX_OSERR;
1068
free(direntries[i]);
1069
goto fallback;
685
1070
}
686
// Starting a new process to be watched
687
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);
688
1076
if(pid == -1){
689
perror("fork");
690
exitstatus = EXIT_FAILURE;
691
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;
692
1085
}
693
1086
if(pid == 0){
694
1087
/* this is the child process */
695
1088
ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
696
1089
if(ret < 0){
697
perror("sigaction");
698
_exit(EXIT_FAILURE);
1090
error(0, errno, "sigaction");
1091
_exit(EX_OSERR);
699
1092
}
700
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
1093
ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
701
1094
if(ret < 0){
702
perror("sigprocmask");
703
_exit(EXIT_FAILURE);
1095
error(0, errno, "sigprocmask");
1096
_exit(EX_OSERR);
704
1097
}
705
1098
706
1099
ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
707
1100
if(ret == -1){
708
perror("dup2");
709
_exit(EXIT_FAILURE);
1101
error(0, errno, "dup2");
1102
_exit(EX_OSERR);
710
1103
}
711
1104
712
if(dirfd(dir) < 0){
713
/* If dir has no file descriptor, we could not set FD_CLOEXEC
714
above and must now close it manually here. */
715
closedir(dir);
716
}
717
if(p->environ[0] == NULL){
718
if(execv(filename, p->argv) < 0){
719
perror("execv");
720
_exit(EXIT_FAILURE);
721
}
722
} else {
723
if(execve(filename, p->argv, p->environ) < 0){
724
perror("execve");
725
_exit(EXIT_FAILURE);
726
}
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);
727
1111
}
728
1112
/* no return */
729
1113
}
730
/* parent process */
731
free(filename);
732
close(pipefd[1]); /* close unused write end of pipe */
733
process *new_process = malloc(sizeof(process));
734
if (new_process == NULL){
735
perror("malloc");
736
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)));
737
1123
if(ret < 0){
738
perror("sigprocmask");
1124
error(0, errno, "sigprocmask");
739
1125
}
740
exitstatus = EXIT_FAILURE;
741
goto end;
1126
exitstatus = EX_OSERR;
1127
free(direntries[i]);
1128
goto fallback;
742
1129
}
1130
free(direntries[i]);
743
1131
744
*new_process = (struct process){ .pid = pid,
745
.fd = pipefd[0],
746
.next = process_list };
747
// List handling
748
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
749
1140
/* Unblock SIGCHLD so signal handler can be run if this process
750
1141
has already completed */
751
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));
752
1145
if(ret < 0){
753
perror("sigprocmask");
754
exitstatus = EXIT_FAILURE;
755
goto end;
756
}
757
758
FD_SET(new_process->fd, &rfds_all);
759
760
if (maxfd < new_process->fd){
761
maxfd = new_process->fd;
762
}
763
764
}
765
766
/* Free the plugin list */
767
for(plugin *next; plugin_list != NULL; plugin_list = next){
768
next = plugin_list->next;
769
free(plugin_list->argv);
770
if(plugin_list->environ[0] != NULL){
771
for(char **e = plugin_list->environ; *e != NULL; e++){
772
free(*e);
773
}
774
}
775
free(plugin_list);
776
}
777
778
closedir(dir);
779
dir = NULL;
780
781
if (process_list == NULL){
782
fprintf(stderr, "No plugin processes started. Incorrect plugin"
783
" directory?\n");
784
process_list = NULL;
785
}
786
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){
787
1177
fd_set rfds = rfds_all;
788
1178
int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
789
if (select_ret == -1){
790
perror("select");
791
exitstatus = EXIT_FAILURE;
792
goto end;
1179
if(select_ret == -1 and errno != EINTR){
1180
error(0, errno, "select");
1181
exitstatus = EX_OSERR;
1182
goto fallback;
793
1183
}
794
1184
/* OK, now either a process completed, or something can be read
795
1185
from one of them */
796
for(process *proc = process_list; proc ; proc = proc->next){
1186
for(plugin *proc = plugin_list; proc != NULL;){
797
1187
/* Is this process completely done? */
798
if(proc->eof and proc->completed){
1188
if(proc->completed and proc->eof){
799
1189
/* Only accept the plugin output if it exited cleanly */
800
1190
if(not WIFEXITED(proc->status)
801
1191
or WEXITSTATUS(proc->status) != 0){
802
1192
/* Bad exit by plugin */
1193
803
1194
if(debug){
804
1195
if(WIFEXITED(proc->status)){
805
fprintf(stderr, "Plugin %u exited with status %d\n",
806
(unsigned int) (proc->pid),
1196
fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
1197
" status %d\n", proc->name,
1198
(intmax_t) (proc->pid),
807
1199
WEXITSTATUS(proc->status));
808
} else if(WIFSIGNALED(proc->status)) {
809
fprintf(stderr, "Plugin %u killed by signal %d\n",
810
(unsigned int) (proc->pid),
811
WTERMSIG(proc->status));
812
} else if(WCOREDUMP(proc->status)){
813
fprintf(stderr, "Plugin %d dumped core\n",
814
(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)));
815
1206
}
816
1207
}
1208
817
1209
/* Remove the plugin */
818
1210
FD_CLR(proc->fd, &rfds_all);
1211
819
1212
/* Block signal while modifying process_list */
820
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));
821
1217
if(ret < 0){
822
perror("sigprocmask");
823
exitstatus = EXIT_FAILURE;
824
goto end;
825
}
826
/* Delete this process entry from the list */
827
if(process_list == proc){
828
/* First one - simple */
829
process_list = proc->next;
830
} else {
831
/* Second one or later */
832
for(process *p = process_list; p != NULL; p = p->next){
833
if(p->next == proc){
834
p->next = proc->next;
835
break;
836
}
837
}
838
}
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
839
1227
/* We are done modifying process list, so unblock signal */
840
ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
841
NULL);
1228
ret = (int)(TEMP_FAILURE_RETRY
1229
(sigprocmask(SIG_UNBLOCK,
1230
&sigchld_action.sa_mask, NULL)));
842
1231
if(ret < 0){
843
perror("sigprocmask");
844
}
845
free(proc->buffer);
846
free(proc);
847
/* We deleted this process from the list, so we can't go
848
proc->next. Therefore, start over from the beginning of
849
the process list */
850
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;
851
1242
}
1243
852
1244
/* This process exited nicely, so print its buffer */
853
854
bool bret = print_out_password(proc->buffer, proc->buffer_length);
1245
1246
bool bret = print_out_password(proc->buffer,
1247
proc->buffer_length);
855
1248
if(not bret){
856
perror("print_out_password");
857
exitstatus = EXIT_FAILURE;
1249
error(0, errno, "print_out_password");
1250
exitstatus = EX_IOERR;
858
1251
}
859
goto end;
1252
goto fallback;
860
1253
}
1254
861
1255
/* This process has not completed. Does it have any output? */
862
1256
if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
863
1257
/* This process had nothing to say at this time */
1258
proc = proc->next;
864
1259
continue;
865
1260
}
866
1261
/* Before reading, make the process' data buffer large enough */
867
1262
if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
868
proc->buffer = realloc(proc->buffer, proc->buffer_size
869
+ (size_t) BUFFER_SIZE);
870
if (proc->buffer == NULL){
871
perror("malloc");
872
exitstatus = EXIT_FAILURE;
873
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;
874
1269
}
1270
proc->buffer = new_buffer;
875
1271
proc->buffer_size += BUFFER_SIZE;
876
1272
}
877
1273
/* Read from the process */
878
ret = read(proc->fd, proc->buffer + proc->buffer_length,
879
BUFFER_SIZE);
880
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){
881
1279
/* Read error from this process; ignore the error */
1280
proc = proc->next;
882
1281
continue;
883
1282
}
884
if(ret == 0){
1283
if(sret == 0){
885
1284
/* got EOF */
886
1285
proc->eof = true;
887
1286
} else {
888
proc->buffer_length += (size_t) ret;
1287
proc->buffer_length += (size_t) sret;
889
1288
}
890
1289
}
891
1290
}
892
893
894
end:
895
896
if(process_list == NULL or exitstatus != EXIT_SUCCESS){
897
/* 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 */
898
1299
bool bret;
899
1300
fprintf(stderr, "Going to fallback mode using getpass(3)\n");
900
1301
char *passwordbuffer = getpass("Password: ");
901
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);
902
1309
if(not bret){
903
perror("print_out_password");
904
exitstatus = EXIT_FAILURE;
905
goto end;
1310
error(0, errno, "print_out_password");
1311
exitstatus = EX_IOERR;
906
1312
}
907
1313
}
908
1314
909
1315
/* Restore old signal handler */
910
sigaction(SIGCHLD, &old_sigchld_action, NULL);
911
912
free(custom_argv);
913
914
/* Free the plugin list */
915
for(plugin *next; plugin_list != NULL; plugin_list = next){
916
next = plugin_list->next;
917
free(plugin_list->argv);
918
if(plugin_list->environ[0] != NULL){
919
for(char **e = plugin_list->environ; *e != NULL; e++){
920
free(*e);
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");
921
1343
}
922
1344
}
923
free(plugin_list->environ);
924
free(plugin_list);
925
}
926
927
if(dir != NULL){
928
closedir(dir);
929
}
930
931
/* Free the process list and kill the processes */
932
for(process *next; process_list != NULL; process_list = next){
933
next = process_list->next;
934
close(process_list->fd);
935
ret = kill(process_list->pid, SIGTERM);
936
if(ret == -1 and errno != ESRCH){
937
/* set-uid proccesses migth not get closed */
938
perror("kill");
939
}
940
free(process_list->buffer);
941
free(process_list);
942
1345
}
943
1346
944
1347
/* Wait for any remaining child processes to terminate */
945
do{
1348
do {
946
1349
ret = wait(NULL);
947
1350
} while(ret >= 0);
948
1351
if(errno != ECHILD){
949
perror("wait");
1352
error(0, errno, "wait");
950
1353
}
951
1354
1355
free_plugin_list();
1356
1357
free(plugindir);
1358
free(pluginhelperdir);
1359
free(argfile);
1360
952
1361
return exitstatus;
953
1362
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0