/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugins.d/usplash.c

  • Committer: Teddy Hogeborn
  • Date: 2008-07-20 06:33:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080720063348-jscgy5p0itrgvlo8
* mandos-clients.conf ([foo]): Uncommented.
  ([foo]/secret): New.
  ([foo]/secfile): Commented out.
  ([foo]/checker): Changed to "fping -q -- %%(fqdn)s".
  ([foo]/timeout): New.

* server.py: New modeline for Python and Emacs.  Set a logging format.
  (Client.__init__): Bug fix: Choose either the value from the options
                     object or pass the argument through string_to_delta
                     for both "timeout" and "interval".
  (Client.checker_callback): Bug fix: Do not log spurious "Checker for
                             <foo> failed" messages.
  (Client.start_checker): Moved "Starting checker" log message down to
                          just before actually starting the subprocess.
                          Do not redirect the subprocesses' stdout to a
                          pipe.
  (peer_certificate, fingerprint): Added docstrings.
  (entry_group_state_changed): Call "killme()" instead of
                               "main_loop.quit()".
  (daemon, killme): New functions.
  (exitstatus, main_loop_started): New global variables.
  (__main__): Removed the "--cert", "--key", "--ca", and "--crl"
              options.  Removed the sleep command from the default
              checker.  Add a console logger in debug mode.  Call
              "killme()" instead of "main_loop.quit()" when there are no
              more clients.  Call "daemon()" if not in debug mode.
              Register "cleanup()" to run at exit.  Ignore some
              signals.  Catch DBusException to detect another running
              server and exit cleanly.  Exit with "exitstatus".
  (cleanup): New function.

Show diffs side-by-side

added added

removed removed

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