/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-09-26 05:04:15 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080926050415-20l2y561cgyaq97i
* .bzrignore: Added "plugins/splashy", "plugins/usplash", and a couple
              of intermediate files in "debian/po".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/usplash.c
1
1
#define _GNU_SOURCE             /* asprintf() */
2
2
#include <signal.h>             /* sig_atomic_t, struct sigaction,
3
 
                                   sigemptyset(), sigaddset(), SIGINT,
4
 
                                   SIGHUP, SIGTERM, sigaction(),
5
 
                                   SIG_IGN, kill(), SIGKILL */
6
 
#include <stdbool.h>            /* bool, false, true */
7
 
#include <fcntl.h>              /* open(), O_WRONLY, O_RDONLY */
8
 
#include <errno.h>              /* errno, EINTR */
9
 
#include <sys/types.h>          /* size_t, ssize_t, pid_t, DIR,
10
 
                                   struct dirent */
 
3
                                   sigemptyset(), sigaddset(),
 
4
                                   sigaction, SIGINT, SIG_IGN, SIGHUP,
 
5
                                   SIGTERM, kill(), SIGKILL */
11
6
#include <stddef.h>             /* NULL */
12
 
#include <string.h>             /* strlen(), memcmp() */
 
7
#include <stdlib.h>             /* getenv() */
13
8
#include <stdio.h>              /* asprintf(), perror() */
14
 
#include <unistd.h>             /* close(), write(), readlink(),
15
 
                                   read(), STDOUT_FILENO, sleep(),
16
 
                                   fork(), setuid(), geteuid(),
17
 
                                   setsid(), chdir(), dup2(),
18
 
                                   STDERR_FILENO, execv() */
19
 
#include <stdlib.h>             /* free(), EXIT_FAILURE, strtoul(),
20
 
                                   realloc(), EXIT_SUCCESS, malloc(),
21
 
                                   _exit() */
22
 
#include <stdlib.h>             /* getenv() */
 
9
#include <stdlib.h>             /* EXIT_FAILURE, EXIT_SUCCESS,
 
10
                                   strtoul(), free() */
 
11
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
 
12
                                   ssize_t */
23
13
#include <dirent.h>             /* opendir(), readdir(), closedir() */
24
 
 
25
 
 
26
 
 
 
14
#include <unistd.h>             /* readlink(), fork(), execl(),
 
15
                                   _exit */
 
16
#include <string.h>             /* memcmp() */
27
17
#include <iso646.h>             /* and */
 
18
#include <stdbool.h>            /* bool, false, true */
 
19
#include <errno.h>              /* errno */
28
20
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
29
21
                                   WEXITSTATUS() */
 
22
#include <fcntl.h>              /* open(), O_RDONLY */
30
23
 
31
24
sig_atomic_t interrupted_by_signal = 0;
32
25
 
51
44
  }while(fifo_fd == -1);
52
45
  
53
46
  const char *cmd_line;
54
 
  size_t cmd_line_len;
55
47
  char *cmd_line_alloc = NULL;
56
48
  if(arg == NULL){
57
49
    cmd_line = cmd;
58
 
    cmd_line_len = strlen(cmd);
 
50
    ret = (int)strlen(cmd);
59
51
  }else{
60
52
    do{
61
53
      ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
67
59
      }
68
60
    }while(ret == -1);
69
61
    cmd_line = cmd_line_alloc;
70
 
    cmd_line_len = (size_t)ret + 1;
71
62
  }
72
63
  
 
64
  size_t cmd_line_len = (size_t)ret + 1;
73
65
  size_t written = 0;
74
66
  while(not interrupted_by_signal and written < cmd_line_len){
75
67
    ret = write(fifo_fd, cmd_line + written,
111
103
  {
112
104
    const char *const cryptsource = getenv("cryptsource");
113
105
    const char *const crypttarget = getenv("crypttarget");
114
 
    const char prompt_start[] = "Enter passphrase to unlock the disk";
 
106
    const char *const prompt_start = "Enter passphrase to unlock the disk";
115
107
    
116
108
    if(cryptsource == NULL){
117
109
      if(crypttarget == NULL){
167
159
        }
168
160
        sret = readlink(exe_link, exe_target, sizeof(exe_target));
169
161
        free(exe_link);
170
 
        if(sret == -1){
171
 
          continue;
172
 
        }
173
162
      }
174
163
      if((sret == ((ssize_t)sizeof(exe_target)-1))
175
164
         and (memcmp(usplash_name, exe_target,
382
371
    
383
372
    /* Print password to stdout */
384
373
    size_t written = 0;
385
 
    while(written < buf_len){
 
374
    do{
386
375
      do{
387
376
        sret = write(STDOUT_FILENO, buf + written, buf_len - written);
388
377
        if(sret == -1){
399
388
      if(interrupted_by_signal or an_error_occured){
400
389
        break;
401
390
      }
 
391
      
402
392
      written += (size_t)sret;
403
 
    }
404
 
    free(buf);
 
393
    }while(written < buf_len);
405
394
    if(not interrupted_by_signal and not an_error_occured){
406
 
      free(cmdline);
407
395
      return EXIT_SUCCESS;
408
396
    }
409
397
    break;                      /* Big */
418
406
    size_t position = 0;
419
407
    while(position < cmdline_len){
420
408
      char **tmp = realloc(cmdline_argv,
421
 
                           (sizeof(char *)
422
 
                            * (size_t)(cmdline_argc + 2)));
 
409
                           (sizeof(char *) * (size_t)(cmdline_argc + 2)));
423
410
      if(tmp == NULL){
424
411
        perror("realloc");
425
412
        free(cmdline_argv);
462
449
    }
463
450
    
464
451
    execv(usplash_name, cmdline_argv);
465
 
    perror("execv");
466
 
    free(cmdline);
467
 
    free(cmdline_argv);
468
 
    _exit(EXIT_FAILURE);
469
452
  }
470
 
  free(cmdline);
471
 
  free(cmdline_argv);
472
453
  sleep(2);
473
454
  if(not usplash_write("PULSATE", NULL)
474
455
     and (errno != EINTR)){