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