To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/usplash.c
- browse files at revision 13
- compare with another revision
- download diff
- download tarball
- view history from revision 13
- Committer: Björn Påhlsson
- Date: 2008-07-20 02:52:20 UTC
- Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
Avahi instead of udp server discovery
openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server
Pluginbased client handler
rewritten Mandos client
Avahi instead of udp server discovery
openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
plugins.d/usplash.c
1
#define _GNU_SOURCE /* asprintf() */
2
#include <signal.h> /* sig_atomic_t, struct sigaction,
3
sigemptyset(), sigaddset(), SIGINT,
4
SIGHUP, SIGTERM, sigaction(),
5
SIG_IGN, kill(), SIGKILL */
6
#include <stdbool.h> /* bool, false, true */
7
#include <fcntl.h> /* open(), O_WRONLY, O_RDONLY */
8
#include <errno.h> /* errno, EINTR */
9
#include <sys/types.h> /* size_t, ssize_t, pid_t, DIR,
10
struct dirent */
11
#include <stddef.h> /* NULL */
12
#include <string.h> /* strlen(), memcmp() */
13
#include <stdio.h> /* asprintf(), perror() */
14
#include <unistd.h> /* close(), write(), readlink(),
15
read(), STDOUT_FILENO, sleep(),
16
fork(), setuid(), geteuid(),
17
setsid(), chdir(), dup2(),
18
STDERR_FILENO, execv() */
19
#include <stdlib.h> /* free(), EXIT_FAILURE, strtoul(),
20
realloc(), EXIT_SUCCESS, malloc(),
21
_exit() */
22
#include <stdlib.h> /* getenv() */
23
#include <dirent.h> /* opendir(), readdir(), closedir() */
24
25
26
27
#include <iso646.h> /* and */
28
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
29
WEXITSTATUS() */
30
31
sig_atomic_t interrupted_by_signal = 0;
32
33
static void termination_handler(__attribute__((unused))int signum){
34
interrupted_by_signal = 1;
35
}
36
37
static bool usplash_write(const char *cmd, const char *arg){
38
/*
39
* usplash_write("TIMEOUT", "15"); -> "TIMEOUT 15\0"
40
* usplash_write("PULSATE", NULL); -> "PULSATE\0"
41
* SEE ALSO
42
* usplash_write(8)
43
*/
44
int ret;
45
int fifo_fd;
46
do{
47
fifo_fd = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
48
if(fifo_fd == -1 and (errno != EINTR or interrupted_by_signal)){
49
return false;
50
}
51
}while(fifo_fd == -1);
52
53
const char *cmd_line;
54
size_t cmd_line_len;
55
char *cmd_line_alloc = NULL;
56
if(arg == NULL){
57
cmd_line = cmd;
58
cmd_line_len = strlen(cmd);
59
}else{
60
do{
61
ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
62
if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
63
int e = errno;
64
close(fifo_fd);
65
errno = e;
66
return false;
67
}
68
}while(ret == -1);
69
cmd_line = cmd_line_alloc;
70
cmd_line_len = (size_t)ret + 1;
71
}
72
73
size_t written = 0;
74
while(not interrupted_by_signal and written < cmd_line_len){
75
ret = write(fifo_fd, cmd_line + written,
76
cmd_line_len - written);
77
if(ret == -1){
78
if(errno != EINTR or interrupted_by_signal){
79
int e = errno;
80
close(fifo_fd);
81
free(cmd_line_alloc);
82
errno = e;
83
return false;
84
} else {
85
continue;
86
}
87
}
88
written += (size_t)ret;
89
}
90
free(cmd_line_alloc);
91
do{
92
ret = close(fifo_fd);
93
if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
94
return false;
95
}
96
}while(ret == -1);
97
if(interrupted_by_signal){
98
return false;
99
}
100
return true;
101
}
102
103
int main(__attribute__((unused))int argc,
104
__attribute__((unused))char **argv){
105
int ret = 0;
106
ssize_t sret;
107
bool an_error_occured = false;
108
109
/* Create prompt string */
110
char *prompt = NULL;
111
{
112
const char *const cryptsource = getenv("cryptsource");
113
const char *const crypttarget = getenv("crypttarget");
114
const char prompt_start[] = "Enter passphrase to unlock the disk";
115
116
if(cryptsource == NULL){
117
if(crypttarget == NULL){
118
ret = asprintf(&prompt, "%s: ", prompt_start);
119
} else {
120
ret = asprintf(&prompt, "%s (%s): ", prompt_start,
121
crypttarget);
122
}
123
} else {
124
if(crypttarget == NULL){
125
ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
126
} else {
127
ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
128
cryptsource, crypttarget);
129
}
130
}
131
if(ret == -1){
132
return EXIT_FAILURE;
133
}
134
}
135
136
/* Find usplash process */
137
pid_t usplash_pid = 0;
138
char *cmdline = NULL;
139
size_t cmdline_len = 0;
140
const char usplash_name[] = "/sbin/usplash";
141
{
142
DIR *proc_dir = opendir("/proc");
143
if(proc_dir == NULL){
144
free(prompt);
145
perror("opendir");
146
return EXIT_FAILURE;
147
}
148
for(struct dirent *proc_ent = readdir(proc_dir);
149
proc_ent != NULL;
150
proc_ent = readdir(proc_dir)){
151
pid_t pid = (pid_t) strtoul(proc_ent->d_name, NULL, 10);
152
if(pid == 0){
153
/* Not a process */
154
continue;
155
}
156
/* Find the executable name by doing readlink() on the
157
/proc/<pid>/exe link */
158
char exe_target[sizeof(usplash_name)];
159
{
160
char *exe_link;
161
ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
162
if(ret == -1){
163
perror("asprintf");
164
free(prompt);
165
closedir(proc_dir);
166
return EXIT_FAILURE;
167
}
168
sret = readlink(exe_link, exe_target, sizeof(exe_target));
169
free(exe_link);
170
if(sret == -1){
171
continue;
172
}
173
}
174
if((sret == ((ssize_t)sizeof(exe_target)-1))
175
and (memcmp(usplash_name, exe_target,
176
sizeof(exe_target)-1) == 0)){
177
usplash_pid = pid;
178
/* Read and save the command line of usplash in "cmdline" */
179
{
180
/* Open /proc/<pid>/cmdline */
181
int cl_fd;
182
{
183
char *cmdline_filename;
184
ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
185
proc_ent->d_name);
186
if(ret == -1){
187
perror("asprintf");
188
free(prompt);
189
closedir(proc_dir);
190
return EXIT_FAILURE;
191
}
192
cl_fd = open(cmdline_filename, O_RDONLY);
193
if(cl_fd == -1){
194
perror("open");
195
free(cmdline_filename);
196
free(prompt);
197
closedir(proc_dir);
198
return EXIT_FAILURE;
199
}
200
free(cmdline_filename);
201
}
202
size_t cmdline_allocated = 0;
203
char *tmp;
204
const size_t blocksize = 1024;
205
do{
206
if(cmdline_len + blocksize > cmdline_allocated){
207
tmp = realloc(cmdline, cmdline_allocated + blocksize);
208
if(tmp == NULL){
209
perror("realloc");
210
free(cmdline);
211
free(prompt);
212
closedir(proc_dir);
213
return EXIT_FAILURE;
214
}
215
cmdline = tmp;
216
cmdline_allocated += blocksize;
217
}
218
sret = read(cl_fd, cmdline + cmdline_len,
219
cmdline_allocated - cmdline_len);
220
if(sret == -1){
221
perror("read");
222
free(cmdline);
223
free(prompt);
224
closedir(proc_dir);
225
return EXIT_FAILURE;
226
}
227
cmdline_len += (size_t)sret;
228
} while(sret != 0);
229
close(cl_fd);
230
}
231
break;
232
}
233
}
234
closedir(proc_dir);
235
}
236
if(usplash_pid == 0){
237
free(prompt);
238
return EXIT_FAILURE;
239
}
240
241
/* Set up the signal handler */
242
{
243
struct sigaction old_action,
244
new_action = { .sa_handler = termination_handler,
245
.sa_flags = 0 };
246
sigemptyset(&new_action.sa_mask);
247
sigaddset(&new_action.sa_mask, SIGINT);
248
sigaddset(&new_action.sa_mask, SIGHUP);
249
sigaddset(&new_action.sa_mask, SIGTERM);
250
ret = sigaction(SIGINT, NULL, &old_action);
251
if(ret == -1){
252
perror("sigaction");
253
free(prompt);
254
return EXIT_FAILURE;
255
}
256
if (old_action.sa_handler != SIG_IGN){
257
ret = sigaction(SIGINT, &new_action, NULL);
258
if(ret == -1){
259
perror("sigaction");
260
free(prompt);
261
return EXIT_FAILURE;
262
}
263
}
264
ret = sigaction(SIGHUP, NULL, &old_action);
265
if(ret == -1){
266
perror("sigaction");
267
free(prompt);
268
return EXIT_FAILURE;
269
}
270
if (old_action.sa_handler != SIG_IGN){
271
ret = sigaction(SIGHUP, &new_action, NULL);
272
if(ret == -1){
273
perror("sigaction");
274
free(prompt);
275
return EXIT_FAILURE;
276
}
277
}
278
ret = sigaction(SIGTERM, NULL, &old_action);
279
if(ret == -1){
280
perror("sigaction");
281
free(prompt);
282
return EXIT_FAILURE;
283
}
284
if (old_action.sa_handler != SIG_IGN){
285
ret = sigaction(SIGTERM, &new_action, NULL);
286
if(ret == -1){
287
perror("sigaction");
288
free(prompt);
289
return EXIT_FAILURE;
290
}
291
}
292
}
293
294
/* Write command to FIFO */
295
if(not interrupted_by_signal){
296
if(not usplash_write("TIMEOUT", "0")
297
and (errno != EINTR)){
298
perror("usplash_write");
299
an_error_occured = true;
300
}
301
}
302
if(not interrupted_by_signal and not an_error_occured){
303
if(not usplash_write("INPUTQUIET", prompt)
304
and (errno != EINTR)){
305
perror("usplash_write");
306
an_error_occured = true;
307
}
308
}
309
free(prompt);
310
311
/* This is not really a loop; while() is used to be able to "break"
312
out of it; those breaks are marked "Big" */
313
while(not interrupted_by_signal and not an_error_occured){
314
char *buf = NULL;
315
size_t buf_len = 0;
316
317
/* Open FIFO */
318
int fifo_fd;
319
do{
320
fifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
321
if(fifo_fd == -1){
322
if(errno != EINTR){
323
perror("open");
324
an_error_occured = true;
325
break;
326
}
327
if(interrupted_by_signal){
328
break;
329
}
330
}
331
}while(fifo_fd == -1);
332
if(interrupted_by_signal or an_error_occured){
333
break; /* Big */
334
}
335
336
/* Read from FIFO */
337
size_t buf_allocated = 0;
338
const size_t blocksize = 1024;
339
do{
340
if(buf_len + blocksize > buf_allocated){
341
char *tmp = realloc(buf, buf_allocated + blocksize);
342
if(tmp == NULL){
343
perror("realloc");
344
an_error_occured = true;
345
break;
346
}
347
buf = tmp;
348
buf_allocated += blocksize;
349
}
350
do{
351
sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
352
if(sret == -1){
353
if(errno != EINTR){
354
perror("read");
355
an_error_occured = true;
356
break;
357
}
358
if(interrupted_by_signal){
359
break;
360
}
361
}
362
}while(sret == -1);
363
if(interrupted_by_signal or an_error_occured){
364
break;
365
}
366
367
buf_len += (size_t)sret;
368
}while(sret != 0);
369
close(fifo_fd);
370
if(interrupted_by_signal or an_error_occured){
371
break; /* Big */
372
}
373
374
if(not usplash_write("TIMEOUT", "15")
375
and (errno != EINTR)){
376
perror("usplash_write");
377
an_error_occured = true;
378
}
379
if(interrupted_by_signal or an_error_occured){
380
break; /* Big */
381
}
382
383
/* Print password to stdout */
384
size_t written = 0;
385
while(written < buf_len){
386
do{
387
sret = write(STDOUT_FILENO, buf + written, buf_len - written);
388
if(sret == -1){
389
if(errno != EINTR){
390
perror("write");
391
an_error_occured = true;
392
break;
393
}
394
if(interrupted_by_signal){
395
break;
396
}
397
}
398
}while(sret == -1);
399
if(interrupted_by_signal or an_error_occured){
400
break;
401
}
402
written += (size_t)sret;
403
}
404
free(buf);
405
if(not interrupted_by_signal and not an_error_occured){
406
free(cmdline);
407
return EXIT_SUCCESS;
408
}
409
break; /* Big */
410
}
411
412
/* If we got here, an error or interrupt must have happened */
413
414
int cmdline_argc = 0;
415
char **cmdline_argv = malloc(sizeof(char *));
416
/* Create argv and argc for new usplash*/
417
{
418
size_t position = 0;
419
while(position < cmdline_len){
420
char **tmp = realloc(cmdline_argv,
421
(sizeof(char *)
422
* (size_t)(cmdline_argc + 2)));
423
if(tmp == NULL){
424
perror("realloc");
425
free(cmdline_argv);
426
return EXIT_FAILURE;
427
}
428
cmdline_argv = tmp;
429
cmdline_argv[cmdline_argc] = cmdline + position;
430
cmdline_argc++;
431
position += strlen(cmdline + position) + 1;
432
}
433
cmdline_argv[cmdline_argc] = NULL;
434
}
435
/* Kill old usplash */
436
kill(usplash_pid, SIGTERM);
437
sleep(2);
438
while(kill(usplash_pid, 0) == 0){
439
kill(usplash_pid, SIGKILL);
440
sleep(1);
441
}
442
pid_t new_usplash_pid = fork();
443
if(new_usplash_pid == 0){
444
/* Child; will become new usplash process */
445
446
/* Make the effective user ID (root) the only user ID instead of
447
the real user ID (mandos) */
448
ret = setuid(geteuid());
449
if (ret == -1){
450
perror("setuid");
451
}
452
453
setsid();
454
ret = chdir("/");
455
/* if(fork() != 0){ */
456
/* _exit(EXIT_SUCCESS); */
457
/* } */
458
ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
459
if(ret == -1){
460
perror("dup2");
461
_exit(EXIT_FAILURE);
462
}
463
464
execv(usplash_name, cmdline_argv);
465
perror("execv");
466
free(cmdline);
467
free(cmdline_argv);
468
_exit(EXIT_FAILURE);
469
}
470
free(cmdline);
471
free(cmdline_argv);
472
sleep(2);
473
if(not usplash_write("PULSATE", NULL)
474
and (errno != EINTR)){
475
perror("usplash_write");
476
}
477
478
return EXIT_FAILURE;
479
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0