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