/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2008-08-16 03:29:08 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080816032908-ihw7c05r2mnyk389
Add feature to specify custom environment variables for plugins.

* plugin-runner.c (plugin): New members "environ" and "envc" to
                            contain possible custom environment.
  (getplugin): Return NULL on failure instead of doing exit(); all
               callers changed.
  (add_to_char_array): New helper function for "add_argument" and
                       "add_environment".
  (addargument): Renamed to "add_argument".  Return bool.  Call
                 "add_to_char_array" to actually do things.
  (add_environment): New; analogous to "add_argument".
  (addcustomargument): Renamed to "add_to_argv" to avoid confusion
                       with "add_argument".
  (main): New options "--global-envs" and "--envs-for" to specify
          custom environment for plugins.  Print environment for
          plugins in debug mode.  Use asprintf instead of strcpy and
          strcat.  Use execve() for plugins with custom environments.
          Free environment for plugin when freeing plugin list.

Show diffs side-by-side

added added

removed removed

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