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 238
- compare with another revision
- download diff
- download tarball
- view history from revision 238
- Committer: Teddy Hogeborn
- Date: 2008-12-10 01:26:02 UTC
- mfrom: (237.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20081210012602-vhz3h75xkj24t340
First version of a somewhat complete D-Bus server interface. Also
change user/group name to "_mandos".
* debian/mandos.postinst: Rename old "mandos" user and group to
"_mandos"; create "_mandos" user and group
if none exist.
* debian/mandos-client.postinst: - '' -
* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
group name.
* mandos (_datetime_to_dbus_struct): New; was previously local.
(Client.started): Renamed to "last_started". All users changed.
(Client.started): New; boolean.
(Client.dbus_object_path): New.
(Client.check_command): Renamed to "checker_command". All users
changed.
(Client.__init__): Set and use "self.dbus_object_path". Set
"self.started".
(Client.start): Update "self.started". Emit "self.PropertyChanged"
signals for both "started" and "last_started".
(Client.stop): Update "self.started". Emit "self.PropertyChanged"
signal for "started".
(Client.checker_callback): Take additional "command" argument. All
callers changed. Emit
"self.PropertyChanged" signal.
(Client.bump_timeout): Emit "self.PropertyChanged" signal for
"last_checked_ok".
(Client.start_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.stop_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.still_valid): Bug fix: use "getattr(self, started, False)"
instead of "self.started" in case this client
object is so new that the "started" attribute
has not been created yet.
(Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
Client.GetCreated, Client.GetFingerprint, Client.GetHost,
Client.GetInterval, Client.GetName, Client.GetStarted,
Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
Removed; all callers changed.
(Client.CheckerCompleted): Add "condition" and "command" arguments.
All callers changed.
(Client.GetAllProperties, Client.PropertyChanged): New.
(Client.StillValid): Renamed to "IsStillValid".
(Client.StartChecker): Changed to its own function to avoid the
return value from "Client.start_checker()".
(Client.Stop): Changed to its own function to avoid the return value
from "Client.stop()".
(main): Try "_mandos" before "mandos" as user and group name.
Removed inner function "remove_from_clients". New inner
class "MandosServer".
change user/group name to "_mandos".
* debian/mandos.postinst: Rename old "mandos" user and group to
"_mandos"; create "_mandos" user and group
if none exist.
* debian/mandos-client.postinst: - '' -
* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
group name.
* mandos (_datetime_to_dbus_struct): New; was previously local.
(Client.started): Renamed to "last_started". All users changed.
(Client.started): New; boolean.
(Client.dbus_object_path): New.
(Client.check_command): Renamed to "checker_command". All users
changed.
(Client.__init__): Set and use "self.dbus_object_path". Set
"self.started".
(Client.start): Update "self.started". Emit "self.PropertyChanged"
signals for both "started" and "last_started".
(Client.stop): Update "self.started". Emit "self.PropertyChanged"
signal for "started".
(Client.checker_callback): Take additional "command" argument. All
callers changed. Emit
"self.PropertyChanged" signal.
(Client.bump_timeout): Emit "self.PropertyChanged" signal for
"last_checked_ok".
(Client.start_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.stop_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.still_valid): Bug fix: use "getattr(self, started, False)"
instead of "self.started" in case this client
object is so new that the "started" attribute
has not been created yet.
(Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
Client.GetCreated, Client.GetFingerprint, Client.GetHost,
Client.GetInterval, Client.GetName, Client.GetStarted,
Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
Removed; all callers changed.
(Client.CheckerCompleted): Add "condition" and "command" arguments.
All callers changed.
(Client.GetAllProperties, Client.PropertyChanged): New.
(Client.StillValid): Renamed to "IsStillValid".
(Client.StartChecker): Changed to its own function to avoid the
return value from "Client.start_checker()".
(Client.Stop): Changed to its own function to avoid the return value
from "Client.stop()".
(main): Try "_mandos" before "mandos" as user and group name.
Removed inner function "remove_from_clients". New inner
class "MandosServer".
- files added:
- debian/mandos-client.config
- files removed:
- DBUS-API
- debian/source
- network-hooks.d
- files modified:
- .bzrignore
added
removed
plugins.d/usplash.c
1
1
/* -*- coding: utf-8 -*- */
2
2
/*
3
* Usplash - Read a password from usplash and output it
3
* Passprompt - Read a password from usplash and output it
4
4
*
5
* Copyright © 2008-2012 Teddy Hogeborn
6
* Copyright © 2008-2012 Björn Påhlsson
5
* Copyright © 2008 Teddy Hogeborn
6
* Copyright © 2008 Björn Påhlsson
7
7
*
8
8
* This program is free software: you can redistribute it and/or
9
9
* modify it under the terms of the GNU General Public License as
19
19
* along with this program. If not, see
20
20
* <http://www.gnu.org/licenses/>.
21
21
*
22
* Contact the authors at <mandos@recompile.se>.
22
* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
23
* <https://www.fukt.bsnet.se/~teddy/>.
23
24
*/
24
25
25
#define _GNU_SOURCE /* asprintf(), TEMP_FAILURE_RETRY() */
26
#define _GNU_SOURCE /* asprintf() */
26
27
#include <signal.h> /* sig_atomic_t, struct sigaction,
27
28
sigemptyset(), sigaddset(), SIGINT,
28
29
SIGHUP, SIGTERM, sigaction(),
31
32
#include <fcntl.h> /* open(), O_WRONLY, O_RDONLY */
32
33
#include <iso646.h> /* and, or, not*/
33
34
#include <errno.h> /* errno, EINTR */
34
#include <error.h>
35
35
#include <sys/types.h> /* size_t, ssize_t, pid_t, DIR, struct
36
36
dirent */
37
37
#include <stddef.h> /* NULL */
38
#include <string.h> /* strlen(), memcmp(), strerror() */
39
#include <stdio.h> /* asprintf(), vasprintf(), vprintf(),
40
fprintf() */
38
#include <string.h> /* strlen(), memcmp() */
39
#include <stdio.h> /* asprintf(), perror() */
41
40
#include <unistd.h> /* close(), write(), readlink(),
42
41
read(), STDOUT_FILENO, sleep(),
43
42
fork(), setuid(), geteuid(),
44
43
setsid(), chdir(), dup2(),
45
44
STDERR_FILENO, execv() */
46
#include <stdlib.h> /* free(), EXIT_FAILURE, realloc(),
47
EXIT_SUCCESS, malloc(), _exit(),
48
getenv() */
45
#include <stdlib.h> /* free(), EXIT_FAILURE, strtoul(),
46
realloc(), EXIT_SUCCESS, malloc(),
47
_exit() */
48
#include <stdlib.h> /* getenv() */
49
49
#include <dirent.h> /* opendir(), readdir(), closedir() */
50
#include <inttypes.h> /* intmax_t, strtoimax() */
51
50
#include <sys/stat.h> /* struct stat, lstat(), S_ISLNK */
52
#include <sysexits.h> /* EX_OSERR, EX_UNAVAILABLE */
53
#include <argz.h> /* argz_count(), argz_extract() */
54
#include <stdarg.h> /* va_list, va_start(), ... */
55
51
56
52
sig_atomic_t interrupted_by_signal = 0;
57
int signal_received;
58
const char usplash_name[] = "/sbin/usplash";
59
60
/* Function to use when printing errors */
61
__attribute__((format (gnu_printf, 3, 4)))
62
void error_plus(int status, int errnum, const char *formatstring,
63
...){
64
va_list ap;
65
char *text;
66
int ret;
67
68
va_start(ap, formatstring);
69
ret = vasprintf(&text, formatstring, ap);
70
if (ret == -1){
71
fprintf(stderr, "Mandos plugin %s: ",
72
program_invocation_short_name);
73
vfprintf(stderr, formatstring, ap);
74
fprintf(stderr, ": ");
75
fprintf(stderr, "%s\n", strerror(errnum));
76
error(status, errno, "vasprintf while printing error");
77
return;
78
}
79
fprintf(stderr, "Mandos plugin ");
80
error(status, errnum, "%s", text);
81
free(text);
82
}
83
84
static void termination_handler(int signum){
85
if(interrupted_by_signal){
86
return;
87
}
53
54
static void termination_handler(__attribute__((unused))int signum){
88
55
interrupted_by_signal = 1;
89
signal_received = signum;
90
56
}
91
57
92
static bool usplash_write(int *fifo_fd_r,
93
const char *cmd, const char *arg){
58
static bool usplash_write(const char *cmd, const char *arg){
94
59
/*
95
* usplash_write(&fd, "TIMEOUT", "15") will write "TIMEOUT 15\0"
96
* usplash_write(&fd, "PULSATE", NULL) will write "PULSATE\0"
60
* usplash_write("TIMEOUT", "15") will write "TIMEOUT 15\0"
61
* usplash_write("PULSATE", NULL) will write "PULSATE\0"
97
62
* SEE ALSO
98
63
* usplash_write(8)
99
64
*/
100
65
int ret;
101
if(*fifo_fd_r == -1){
102
ret = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
103
if(ret == -1){
66
int fifo_fd;
67
do{
68
fifo_fd = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
69
if(fifo_fd == -1 and (errno != EINTR or interrupted_by_signal)){
104
70
return false;
105
71
}
106
*fifo_fd_r = ret;
107
}
72
}while(fifo_fd == -1);
108
73
109
74
const char *cmd_line;
110
75
size_t cmd_line_len;
111
76
char *cmd_line_alloc = NULL;
112
77
if(arg == NULL){
113
78
cmd_line = cmd;
114
cmd_line_len = strlen(cmd) + 1;
115
} else {
116
do {
79
cmd_line_len = strlen(cmd);
80
}else{
81
do{
117
82
ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
118
if(ret == -1){
83
if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
119
84
int e = errno;
120
TEMP_FAILURE_RETRY(close(*fifo_fd_r));
85
close(fifo_fd);
121
86
errno = e;
122
87
return false;
123
88
}
124
} while(ret == -1);
89
}while(ret == -1);
125
90
cmd_line = cmd_line_alloc;
126
91
cmd_line_len = (size_t)ret + 1;
127
92
}
128
93
129
94
size_t written = 0;
130
ssize_t sret = 0;
131
while(written < cmd_line_len){
132
sret = write(*fifo_fd_r, cmd_line + written,
133
cmd_line_len - written);
134
if(sret == -1){
135
int e = errno;
136
TEMP_FAILURE_RETRY(close(*fifo_fd_r));
137
free(cmd_line_alloc);
138
errno = e;
139
return false;
95
while(not interrupted_by_signal and written < cmd_line_len){
96
ret = write(fifo_fd, cmd_line + written,
97
cmd_line_len - written);
98
if(ret == -1){
99
if(errno != EINTR or interrupted_by_signal){
100
int e = errno;
101
close(fifo_fd);
102
free(cmd_line_alloc);
103
errno = e;
104
return false;
105
} else {
106
continue;
107
}
140
108
}
141
written += (size_t)sret;
109
written += (size_t)ret;
142
110
}
143
111
free(cmd_line_alloc);
144
112
do{
113
ret = close(fifo_fd);
114
if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
115
return false;
116
}
117
}while(ret == -1);
118
if(interrupted_by_signal){
119
return false;
120
}
145
121
return true;
146
122
}
147
123
148
/* Create prompt string */
149
char *makeprompt(void){
150
int ret = 0;
151
char *prompt;
152
const char *const cryptsource = getenv("cryptsource");
153
const char *const crypttarget = getenv("crypttarget");
154
const char prompt_start[] = "Enter passphrase to unlock the disk";
155
156
if(cryptsource == NULL){
157
if(crypttarget == NULL){
158
ret = asprintf(&prompt, "%s: ", prompt_start);
159
} else {
160
ret = asprintf(&prompt, "%s (%s): ", prompt_start,
161
crypttarget);
162
}
163
} else {
164
if(crypttarget == NULL){
165
ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
166
} else {
167
ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
168
cryptsource, crypttarget);
169
}
170
}
171
if(ret == -1){
172
return NULL;
173
}
174
return prompt;
175
}
176
177
pid_t find_usplash(char **cmdline_r, size_t *cmdline_len_r){
178
int ret = 0;
179
ssize_t sret = 0;
124
int main(__attribute__((unused))int argc,
125
__attribute__((unused))char **argv){
126
int ret = 0;
127
ssize_t sret;
128
bool an_error_occured = false;
129
130
/* Create prompt string */
131
char *prompt = NULL;
132
{
133
const char *const cryptsource = getenv("cryptsource");
134
const char *const crypttarget = getenv("crypttarget");
135
const char prompt_start[] = "Enter passphrase to unlock the disk";
136
137
if(cryptsource == NULL){
138
if(crypttarget == NULL){
139
ret = asprintf(&prompt, "%s: ", prompt_start);
140
} else {
141
ret = asprintf(&prompt, "%s (%s): ", prompt_start,
142
crypttarget);
143
}
144
} else {
145
if(crypttarget == NULL){
146
ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
147
} else {
148
ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
149
cryptsource, crypttarget);
150
}
151
}
152
if(ret == -1){
153
return EXIT_FAILURE;
154
}
155
}
156
157
/* Find usplash process */
158
pid_t usplash_pid = 0;
180
159
char *cmdline = NULL;
181
160
size_t cmdline_len = 0;
182
DIR *proc_dir = opendir("/proc");
183
if(proc_dir == NULL){
184
error_plus(0, errno, "opendir");
185
return -1;
186
}
187
errno = 0;
188
for(struct dirent *proc_ent = readdir(proc_dir);
189
proc_ent != NULL;
190
proc_ent = readdir(proc_dir)){
191
pid_t pid;
192
{
193
intmax_t tmpmax;
194
char *tmp;
195
tmpmax = strtoimax(proc_ent->d_name, &tmp, 10);
196
if(errno != 0 or tmp == proc_ent->d_name or *tmp != '\0'
197
or tmpmax != (pid_t)tmpmax){
161
const char usplash_name[] = "/sbin/usplash";
162
{
163
DIR *proc_dir = opendir("/proc");
164
if(proc_dir == NULL){
165
free(prompt);
166
perror("opendir");
167
return EXIT_FAILURE;
168
}
169
for(struct dirent *proc_ent = readdir(proc_dir);
170
proc_ent != NULL;
171
proc_ent = readdir(proc_dir)){
172
pid_t pid = (pid_t) strtoul(proc_ent->d_name, NULL, 10);
173
if(pid == 0){
198
174
/* Not a process */
199
errno = 0;
200
continue;
201
}
202
pid = (pid_t)tmpmax;
203
}
204
/* Find the executable name by doing readlink() on the
205
/proc/<pid>/exe link */
206
char exe_target[sizeof(usplash_name)];
207
{
208
/* create file name string */
209
char *exe_link;
210
ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
211
if(ret == -1){
212
error_plus(0, errno, "asprintf");
213
goto fail_find_usplash;
214
}
215
216
/* Check that it refers to a symlink owned by root:root */
217
struct stat exe_stat;
218
ret = lstat(exe_link, &exe_stat);
219
if(ret == -1){
220
if(errno == ENOENT){
221
free(exe_link);
222
continue;
223
}
224
error_plus(0, errno, "lstat");
225
free(exe_link);
226
goto fail_find_usplash;
227
}
228
if(not S_ISLNK(exe_stat.st_mode)
229
or exe_stat.st_uid != 0
230
or exe_stat.st_gid != 0){
231
free(exe_link);
232
continue;
233
}
234
235
sret = readlink(exe_link, exe_target, sizeof(exe_target));
236
free(exe_link);
237
}
238
/* Compare executable name */
239
if((sret != ((ssize_t)sizeof(exe_target)-1))
240
or (memcmp(usplash_name, exe_target,
241
sizeof(exe_target)-1) != 0)){
242
/* Not it */
243
continue;
244
}
245
/* Found usplash */
246
/* Read and save the command line of usplash in "cmdline" */
247
{
248
/* Open /proc/<pid>/cmdline */
249
int cl_fd;
175
continue;
176
}
177
/* Find the executable name by doing readlink() on the
178
/proc/<pid>/exe link */
179
char exe_target[sizeof(usplash_name)];
250
180
{
251
char *cmdline_filename;
252
ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
253
proc_ent->d_name);
254
if(ret == -1){
255
error_plus(0, errno, "asprintf");
256
goto fail_find_usplash;
257
}
258
cl_fd = open(cmdline_filename, O_RDONLY);
259
free(cmdline_filename);
260
if(cl_fd == -1){
261
error_plus(0, errno, "open");
262
goto fail_find_usplash;
181
/* create file name string */
182
char *exe_link;
183
ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
184
if(ret == -1){
185
perror("asprintf");
186
free(prompt);
187
closedir(proc_dir);
188
return EXIT_FAILURE;
189
}
190
191
/* Check that it refers to a symlink owned by root:root */
192
struct stat exe_stat;
193
ret = lstat(exe_link, &exe_stat);
194
if(ret == -1){
195
perror("lstat");
196
free(exe_link);
197
free(prompt);
198
closedir(proc_dir);
199
return EXIT_FAILURE;
200
}
201
if(not S_ISLNK(exe_stat.st_mode)
202
or exe_stat.st_uid != 0
203
or exe_stat.st_gid != 0){
204
free(exe_link);
205
continue;
206
}
207
208
sret = readlink(exe_link, exe_target, sizeof(exe_target));
209
free(exe_link);
210
if(sret == -1){
211
continue;
263
212
}
264
213
}
265
size_t cmdline_allocated = 0;
266
char *tmp;
267
const size_t blocksize = 1024;
268
do {
269
/* Allocate more space? */
270
if(cmdline_len + blocksize > cmdline_allocated){
271
tmp = realloc(cmdline, cmdline_allocated + blocksize);
272
if(tmp == NULL){
273
error_plus(0, errno, "realloc");
274
close(cl_fd);
275
goto fail_find_usplash;
214
if((sret == ((ssize_t)sizeof(exe_target)-1))
215
and (memcmp(usplash_name, exe_target,
216
sizeof(exe_target)-1) == 0)){
217
usplash_pid = pid;
218
/* Read and save the command line of usplash in "cmdline" */
219
{
220
/* Open /proc/<pid>/cmdline */
221
int cl_fd;
222
{
223
char *cmdline_filename;
224
ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
225
proc_ent->d_name);
226
if(ret == -1){
227
perror("asprintf");
228
free(prompt);
229
closedir(proc_dir);
230
return EXIT_FAILURE;
231
}
232
cl_fd = open(cmdline_filename, O_RDONLY);
233
if(cl_fd == -1){
234
perror("open");
235
free(cmdline_filename);
236
free(prompt);
237
closedir(proc_dir);
238
return EXIT_FAILURE;
239
}
240
free(cmdline_filename);
276
241
}
277
cmdline = tmp;
278
cmdline_allocated += blocksize;
279
}
280
/* Read data */
281
sret = read(cl_fd, cmdline + cmdline_len,
282
cmdline_allocated - cmdline_len);
283
if(sret == -1){
284
error_plus(0, errno, "read");
242
size_t cmdline_allocated = 0;
243
char *tmp;
244
const size_t blocksize = 1024;
245
do{
246
if(cmdline_len + blocksize > cmdline_allocated){
247
tmp = realloc(cmdline, cmdline_allocated + blocksize);
248
if(tmp == NULL){
249
perror("realloc");
250
free(cmdline);
251
free(prompt);
252
closedir(proc_dir);
253
return EXIT_FAILURE;
254
}
255
cmdline = tmp;
256
cmdline_allocated += blocksize;
257
}
258
sret = read(cl_fd, cmdline + cmdline_len,
259
cmdline_allocated - cmdline_len);
260
if(sret == -1){
261
perror("read");
262
free(cmdline);
263
free(prompt);
264
closedir(proc_dir);
265
return EXIT_FAILURE;
266
}
267
cmdline_len += (size_t)sret;
268
} while(sret != 0);
285
269
close(cl_fd);
286
goto fail_find_usplash;
287
270
}
288
cmdline_len += (size_t)sret;
289
} while(sret != 0);
290
ret = close(cl_fd);
291
if(ret == -1){
292
error_plus(0, errno, "close");
293
goto fail_find_usplash;
271
break;
294
272
}
295
273
}
296
/* Close directory */
297
ret = closedir(proc_dir);
298
if(ret == -1){
299
error_plus(0, errno, "closedir");
300
goto fail_find_usplash;
301
}
302
/* Success */
303
*cmdline_r = cmdline;
304
*cmdline_len_r = cmdline_len;
305
return pid;
306
}
307
308
fail_find_usplash:
309
310
free(cmdline);
311
if(proc_dir != NULL){
312
int e = errno;
313
274
closedir(proc_dir);
314
errno = e;
315
}
316
return 0;
317
}
318
319
int main(__attribute__((unused))int argc,
320
__attribute__((unused))char **argv){
321
int ret = 0;
322
ssize_t sret;
323
int fifo_fd = -1;
324
int outfifo_fd = -1;
325
char *buf = NULL;
326
size_t buf_len = 0;
327
pid_t usplash_pid = -1;
328
bool usplash_accessed = false;
329
int status = EXIT_FAILURE; /* Default failure exit status */
330
331
char *prompt = makeprompt();
332
if(prompt == NULL){
333
status = EX_OSERR;
334
goto failure;
335
}
336
337
/* Find usplash process */
338
char *cmdline = NULL;
339
size_t cmdline_len = 0;
340
usplash_pid = find_usplash(&cmdline, &cmdline_len);
275
}
341
276
if(usplash_pid == 0){
342
status = EX_UNAVAILABLE;
343
goto failure;
277
free(prompt);
278
return EXIT_FAILURE;
344
279
}
345
280
346
281
/* Set up the signal handler */
349
284
new_action = { .sa_handler = termination_handler,
350
285
.sa_flags = 0 };
351
286
sigemptyset(&new_action.sa_mask);
352
ret = sigaddset(&new_action.sa_mask, SIGINT);
353
if(ret == -1){
354
error_plus(0, errno, "sigaddset");
355
status = EX_OSERR;
356
goto failure;
357
}
358
ret = sigaddset(&new_action.sa_mask, SIGHUP);
359
if(ret == -1){
360
error_plus(0, errno, "sigaddset");
361
status = EX_OSERR;
362
goto failure;
363
}
364
ret = sigaddset(&new_action.sa_mask, SIGTERM);
365
if(ret == -1){
366
error_plus(0, errno, "sigaddset");
367
status = EX_OSERR;
368
goto failure;
369
}
287
sigaddset(&new_action.sa_mask, SIGINT);
288
sigaddset(&new_action.sa_mask, SIGHUP);
289
sigaddset(&new_action.sa_mask, SIGTERM);
370
290
ret = sigaction(SIGINT, NULL, &old_action);
371
291
if(ret == -1){
372
if(errno != EINTR){
373
error_plus(0, errno, "sigaction");
374
status = EX_OSERR;
375
}
376
goto failure;
292
perror("sigaction");
293
free(prompt);
294
return EXIT_FAILURE;
377
295
}
378
296
if(old_action.sa_handler != SIG_IGN){
379
297
ret = sigaction(SIGINT, &new_action, NULL);
380
298
if(ret == -1){
381
if(errno != EINTR){
382
error_plus(0, errno, "sigaction");
383
status = EX_OSERR;
384
}
385
goto failure;
299
perror("sigaction");
300
free(prompt);
301
return EXIT_FAILURE;
386
302
}
387
303
}
388
304
ret = sigaction(SIGHUP, NULL, &old_action);
389
305
if(ret == -1){
390
if(errno != EINTR){
391
error_plus(0, errno, "sigaction");
392
status = EX_OSERR;
393
}
394
goto failure;
306
perror("sigaction");
307
free(prompt);
308
return EXIT_FAILURE;
395
309
}
396
310
if(old_action.sa_handler != SIG_IGN){
397
311
ret = sigaction(SIGHUP, &new_action, NULL);
398
312
if(ret == -1){
399
if(errno != EINTR){
400
error_plus(0, errno, "sigaction");
401
status = EX_OSERR;
402
}
403
goto failure;
313
perror("sigaction");
314
free(prompt);
315
return EXIT_FAILURE;
404
316
}
405
317
}
406
318
ret = sigaction(SIGTERM, NULL, &old_action);
407
319
if(ret == -1){
408
if(errno != EINTR){
409
error_plus(0, errno, "sigaction");
410
status = EX_OSERR;
411
}
412
goto failure;
320
perror("sigaction");
321
free(prompt);
322
return EXIT_FAILURE;
413
323
}
414
324
if(old_action.sa_handler != SIG_IGN){
415
325
ret = sigaction(SIGTERM, &new_action, NULL);
416
326
if(ret == -1){
417
if(errno != EINTR){
418
error_plus(0, errno, "sigaction");
419
status = EX_OSERR;
420
}
421
goto failure;
327
perror("sigaction");
328
free(prompt);
329
return EXIT_FAILURE;
422
330
}
423
331
}
424
332
}
425
333
426
usplash_accessed = true;
427
334
/* Write command to FIFO */
428
if(not usplash_write(&fifo_fd, "TIMEOUT", "0")){
429
if(errno != EINTR){
430
error_plus(0, errno, "usplash_write");
431
status = EX_OSERR;
432
}
433
goto failure;
434
}
435
436
if(interrupted_by_signal){
437
goto failure;
438
}
439
440
if(not usplash_write(&fifo_fd, "INPUTQUIET", prompt)){
441
if(errno != EINTR){
442
error_plus(0, errno, "usplash_write");
443
status = EX_OSERR;
444
}
445
goto failure;
446
}
447
448
if(interrupted_by_signal){
449
goto failure;
450
}
451
335
if(not interrupted_by_signal){
336
if(not usplash_write("TIMEOUT", "0")
337
and (errno != EINTR)){
338
perror("usplash_write");
339
an_error_occured = true;
340
}
341
}
342
if(not interrupted_by_signal and not an_error_occured){
343
if(not usplash_write("INPUTQUIET", prompt)
344
and (errno != EINTR)){
345
perror("usplash_write");
346
an_error_occured = true;
347
}
348
}
452
349
free(prompt);
453
prompt = NULL;
454
455
/* Read reply from usplash */
456
/* Open FIFO */
457
outfifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
458
if(outfifo_fd == -1){
459
if(errno != EINTR){
460
error_plus(0, errno, "open");
461
status = EX_OSERR;
462
}
463
goto failure;
464
}
465
466
if(interrupted_by_signal){
467
goto failure;
468
}
469
470
/* Read from FIFO */
471
size_t buf_allocated = 0;
472
const size_t blocksize = 1024;
473
do {
474
/* Allocate more space */
475
if(buf_len + blocksize > buf_allocated){
476
char *tmp = realloc(buf, buf_allocated + blocksize);
350
351
/* This is not really a loop; while() is used to be able to "break"
352
out of it; those breaks are marked "Big" */
353
while(not interrupted_by_signal and not an_error_occured){
354
char *buf = NULL;
355
size_t buf_len = 0;
356
357
/* Open FIFO */
358
int fifo_fd;
359
do{
360
fifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
361
if(fifo_fd == -1){
362
if(errno != EINTR){
363
perror("open");
364
an_error_occured = true;
365
break;
366
}
367
if(interrupted_by_signal){
368
break;
369
}
370
}
371
}while(fifo_fd == -1);
372
if(interrupted_by_signal or an_error_occured){
373
break; /* Big */
374
}
375
376
/* Read from FIFO */
377
size_t buf_allocated = 0;
378
const size_t blocksize = 1024;
379
do{
380
if(buf_len + blocksize > buf_allocated){
381
char *tmp = realloc(buf, buf_allocated + blocksize);
382
if(tmp == NULL){
383
perror("realloc");
384
an_error_occured = true;
385
break;
386
}
387
buf = tmp;
388
buf_allocated += blocksize;
389
}
390
do{
391
sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
392
if(sret == -1){
393
if(errno != EINTR){
394
perror("read");
395
an_error_occured = true;
396
break;
397
}
398
if(interrupted_by_signal){
399
break;
400
}
401
}
402
}while(sret == -1);
403
if(interrupted_by_signal or an_error_occured){
404
break;
405
}
406
407
buf_len += (size_t)sret;
408
}while(sret != 0);
409
close(fifo_fd);
410
if(interrupted_by_signal or an_error_occured){
411
break; /* Big */
412
}
413
414
if(not usplash_write("TIMEOUT", "15")
415
and (errno != EINTR)){
416
perror("usplash_write");
417
an_error_occured = true;
418
}
419
if(interrupted_by_signal or an_error_occured){
420
break; /* Big */
421
}
422
423
/* Print password to stdout */
424
size_t written = 0;
425
while(written < buf_len){
426
do{
427
sret = write(STDOUT_FILENO, buf + written, buf_len - written);
428
if(sret == -1){
429
if(errno != EINTR){
430
perror("write");
431
an_error_occured = true;
432
break;
433
}
434
if(interrupted_by_signal){
435
break;
436
}
437
}
438
}while(sret == -1);
439
if(interrupted_by_signal or an_error_occured){
440
break;
441
}
442
written += (size_t)sret;
443
}
444
free(buf);
445
if(not interrupted_by_signal and not an_error_occured){
446
free(cmdline);
447
return EXIT_SUCCESS;
448
}
449
break; /* Big */
450
} /* end of non-loop while() */
451
452
/* If we got here, an error or interrupt must have happened */
453
454
/* Create argc and argv for new usplash*/
455
int cmdline_argc = 0;
456
char **cmdline_argv = malloc(sizeof(char *));
457
{
458
size_t position = 0;
459
while(position < cmdline_len){
460
char **tmp = realloc(cmdline_argv,
461
(sizeof(char *)
462
* (size_t)(cmdline_argc + 2)));
477
463
if(tmp == NULL){
478
if(errno != EINTR){
479
error_plus(0, errno, "realloc");
480
status = EX_OSERR;
481
}
482
goto failure;
483
}
484
buf = tmp;
485
buf_allocated += blocksize;
486
}
487
sret = read(outfifo_fd, buf + buf_len,
488
buf_allocated - buf_len);
489
if(sret == -1){
490
if(errno != EINTR){
491
error_plus(0, errno, "read");
492
status = EX_OSERR;
493
}
494
TEMP_FAILURE_RETRY(close(outfifo_fd));
495
goto failure;
496
}
497
if(interrupted_by_signal){
498
break;
499
}
500
501
buf_len += (size_t)sret;
502
} while(sret != 0);
503
ret = close(outfifo_fd);
504
if(ret == -1){
505
if(errno != EINTR){
506
error_plus(0, errno, "close");
507
status = EX_OSERR;
508
}
509
goto failure;
510
}
511
outfifo_fd = -1;
512
513
if(interrupted_by_signal){
514
goto failure;
515
}
516
517
if(not usplash_write(&fifo_fd, "TIMEOUT", "15")){
518
if(errno != EINTR){
519
error_plus(0, errno, "usplash_write");
520
status = EX_OSERR;
521
}
522
goto failure;
523
}
524
525
if(interrupted_by_signal){
526
goto failure;
527
}
528
529
ret = close(fifo_fd);
530
if(ret == -1){
531
if(errno != EINTR){
532
error_plus(0, errno, "close");
533
status = EX_OSERR;
534
}
535
goto failure;
536
}
537
fifo_fd = -1;
538
539
/* Print password to stdout */
540
size_t written = 0;
541
while(written < buf_len){
542
do {
543
sret = write(STDOUT_FILENO, buf + written, buf_len - written);
544
if(sret == -1){
545
if(errno != EINTR){
546
error_plus(0, errno, "write");
547
status = EX_OSERR;
548
}
549
goto failure;
550
}
551
} while(sret == -1);
552
553
if(interrupted_by_signal){
554
goto failure;
555
}
556
written += (size_t)sret;
557
}
558
free(buf);
559
buf = NULL;
560
561
if(interrupted_by_signal){
562
goto failure;
563
}
564
565
free(cmdline);
566
return EXIT_SUCCESS;
567
568
failure:
569
570
free(buf);
571
572
free(prompt);
573
574
/* If usplash was never accessed, we can stop now */
575
if(not usplash_accessed){
576
return status;
577
}
578
579
/* Close FIFO */
580
if(fifo_fd != -1){
581
ret = (int)TEMP_FAILURE_RETRY(close(fifo_fd));
582
if(ret == -1 and errno != EINTR){
583
error_plus(0, errno, "close");
584
}
585
fifo_fd = -1;
586
}
587
588
/* Close output FIFO */
589
if(outfifo_fd != -1){
590
ret = (int)TEMP_FAILURE_RETRY(close(outfifo_fd));
591
if(ret == -1){
592
error_plus(0, errno, "close");
593
}
594
}
595
596
/* Create argv for new usplash*/
597
char **cmdline_argv = malloc((argz_count(cmdline, cmdline_len) + 1)
598
* sizeof(char *)); /* Count args */
599
if(cmdline_argv == NULL){
600
error_plus(0, errno, "malloc");
601
return status;
602
}
603
argz_extract(cmdline, cmdline_len, cmdline_argv); /* Create argv */
604
464
perror("realloc");
465
free(cmdline_argv);
466
return EXIT_FAILURE;
467
}
468
cmdline_argv = tmp;
469
cmdline_argv[cmdline_argc] = cmdline + position;
470
cmdline_argc++;
471
position += strlen(cmdline + position) + 1;
472
}
473
cmdline_argv[cmdline_argc] = NULL;
474
}
605
475
/* Kill old usplash */
606
476
kill(usplash_pid, SIGTERM);
607
477
sleep(2);
609
479
kill(usplash_pid, SIGKILL);
610
480
sleep(1);
611
481
}
612
613
482
pid_t new_usplash_pid = fork();
614
483
if(new_usplash_pid == 0){
615
484
/* Child; will become new usplash process */
616
485
617
486
/* Make the effective user ID (root) the only user ID instead of
618
the real user ID (_mandos) */
487
the real user ID (mandos) */
619
488
ret = setuid(geteuid());
620
489
if(ret == -1){
621
error_plus(0, errno, "setuid");
490
perror("setuid");
622
491
}
623
492
624
493
setsid();
625
494
ret = chdir("/");
626
if(ret == -1){
627
error_plus(0, errno, "chdir");
628
_exit(EX_OSERR);
629
}
630
495
/* if(fork() != 0){ */
631
496
/* _exit(EXIT_SUCCESS); */
632
497
/* } */
633
498
ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
634
499
if(ret == -1){
635
error_plus(0, errno, "dup2");
636
_exit(EX_OSERR);
500
perror("dup2");
501
_exit(EXIT_FAILURE);
637
502
}
638
503
639
504
execv(usplash_name, cmdline_argv);
640
505
if(not interrupted_by_signal){
641
error_plus(0, errno, "execv");
506
perror("execv");
642
507
}
643
508
free(cmdline);
644
509
free(cmdline_argv);
645
_exit(EX_OSERR);
510
_exit(EXIT_FAILURE);
646
511
}
647
512
free(cmdline);
648
513
free(cmdline_argv);
649
514
sleep(2);
650
if(not usplash_write(&fifo_fd, "PULSATE", NULL)){
651
if(errno != EINTR){
652
error_plus(0, errno, "usplash_write");
653
}
654
}
655
656
/* Close FIFO (again) */
657
if(fifo_fd != -1){
658
ret = (int)TEMP_FAILURE_RETRY(close(fifo_fd));
659
if(ret == -1 and errno != EINTR){
660
error_plus(0, errno, "close");
661
}
662
fifo_fd = -1;
663
}
664
665
if(interrupted_by_signal){
666
struct sigaction signal_action = { .sa_handler = SIG_DFL };
667
sigemptyset(&signal_action.sa_mask);
668
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
669
&signal_action, NULL));
670
if(ret == -1){
671
error_plus(0, errno, "sigaction");
672
}
673
do {
674
ret = raise(signal_received);
675
} while(ret != 0 and errno == EINTR);
676
if(ret != 0){
677
error_plus(0, errno, "raise");
678
abort();
679
}
680
TEMP_FAILURE_RETRY(pause());
681
}
682
683
return status;
515
if(not usplash_write("PULSATE", NULL)
516
and (errno != EINTR)){
517
perror("usplash_write");
518
}
519
520
return EXIT_FAILURE;
684
521
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0