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