/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-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".

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
38
#include <string.h>             /* strlen(), memcmp() */
39
 
#include <stdio.h>              /* asprintf()*/
 
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
51
 
54
52
sig_atomic_t interrupted_by_signal = 0;
55
 
int signal_received;
56
 
const char usplash_name[] = "/sbin/usplash";
57
53
 
58
 
static void termination_handler(int signum){
59
 
  if(interrupted_by_signal){
60
 
    return;
61
 
  }
 
54
static void termination_handler(__attribute__((unused))int signum){
62
55
  interrupted_by_signal = 1;
63
 
  signal_received = signum;
64
56
}
65
57
 
66
 
static bool usplash_write(int *fifo_fd_r,
67
 
                          const char *cmd, const char *arg){
 
58
static bool usplash_write(const char *cmd, const char *arg){
68
59
  /* 
69
 
   * usplash_write(&fd, "TIMEOUT", "15") will write "TIMEOUT 15\0"
70
 
   * 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"
71
62
   * SEE ALSO
72
63
   *         usplash_write(8)
73
64
   */
74
65
  int ret;
75
 
  if(*fifo_fd_r == -1){
76
 
    ret = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
77
 
    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)){
78
70
      return false;
79
71
    }
80
 
    *fifo_fd_r = ret;
81
 
  }
 
72
  }while(fifo_fd == -1);
82
73
  
83
74
  const char *cmd_line;
84
75
  size_t cmd_line_len;
85
76
  char *cmd_line_alloc = NULL;
86
77
  if(arg == NULL){
87
78
    cmd_line = cmd;
88
 
    cmd_line_len = strlen(cmd) + 1;
89
 
  } else {
90
 
    do {
 
79
    cmd_line_len = strlen(cmd);
 
80
  }else{
 
81
    do{
91
82
      ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
92
 
      if(ret == -1){
 
83
      if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
93
84
        int e = errno;
94
 
        TEMP_FAILURE_RETRY(close(*fifo_fd_r));
 
85
        close(fifo_fd);
95
86
        errno = e;
96
87
        return false;
97
88
      }
98
 
    } while(ret == -1);
 
89
    }while(ret == -1);
99
90
    cmd_line = cmd_line_alloc;
100
91
    cmd_line_len = (size_t)ret + 1;
101
92
  }
102
93
  
103
94
  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;
 
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
      }
114
108
    }
115
 
    written += (size_t)sret;
 
109
    written += (size_t)ret;
116
110
  }
117
111
  free(cmd_line_alloc);
118
 
  
 
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
  }
119
121
  return true;
120
122
}
121
123
 
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;
 
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;
154
159
  char *cmdline = NULL;
155
160
  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){
 
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){
172
174
        /* 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;
 
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)];
224
180
      {
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;
 
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;
237
212
        }
238
213
      }
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;
 
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);
250
241
          }
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");
 
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);
259
269
          close(cl_fd);
260
 
          goto fail_find_usplash;
261
270
        }
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;
 
271
        break;
268
272
      }
269
273
    }
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
274
    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);
 
275
  }
315
276
  if(usplash_pid == 0){
316
 
    status = EX_UNAVAILABLE;
317
 
    goto failure;
 
277
    free(prompt);
 
278
    return EXIT_FAILURE;
318
279
  }
319
280
  
320
281
  /* Set up the signal handler */
323
284
      new_action = { .sa_handler = termination_handler,
324
285
                     .sa_flags = 0 };
325
286
    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
 
    }
 
287
    sigaddset(&new_action.sa_mask, SIGINT);
 
288
    sigaddset(&new_action.sa_mask, SIGHUP);
 
289
    sigaddset(&new_action.sa_mask, SIGTERM);
344
290
    ret = sigaction(SIGINT, NULL, &old_action);
345
291
    if(ret == -1){
346
 
      if(errno != EINTR){
347
 
        error(0, errno, "sigaction");
348
 
        status = EX_OSERR;
349
 
      }
350
 
      goto failure;
 
292
      perror("sigaction");
 
293
      free(prompt);
 
294
      return EXIT_FAILURE;
351
295
    }
352
296
    if(old_action.sa_handler != SIG_IGN){
353
297
      ret = sigaction(SIGINT, &new_action, NULL);
354
298
      if(ret == -1){
355
 
        if(errno != EINTR){
356
 
          error(0, errno, "sigaction");
357
 
          status = EX_OSERR;
358
 
        }
359
 
        goto failure;
 
299
        perror("sigaction");
 
300
        free(prompt);
 
301
        return EXIT_FAILURE;
360
302
      }
361
303
    }
362
304
    ret = sigaction(SIGHUP, NULL, &old_action);
363
305
    if(ret == -1){
364
 
      if(errno != EINTR){
365
 
        error(0, errno, "sigaction");
366
 
        status = EX_OSERR;
367
 
      }
368
 
      goto failure;
 
306
      perror("sigaction");
 
307
      free(prompt);
 
308
      return EXIT_FAILURE;
369
309
    }
370
310
    if(old_action.sa_handler != SIG_IGN){
371
311
      ret = sigaction(SIGHUP, &new_action, NULL);
372
312
      if(ret == -1){
373
 
        if(errno != EINTR){
374
 
          error(0, errno, "sigaction");
375
 
          status = EX_OSERR;
376
 
        }
377
 
        goto failure;
 
313
        perror("sigaction");
 
314
        free(prompt);
 
315
        return EXIT_FAILURE;
378
316
      }
379
317
    }
380
318
    ret = sigaction(SIGTERM, NULL, &old_action);
381
319
    if(ret == -1){
382
 
      if(errno != EINTR){
383
 
        error(0, errno, "sigaction");
384
 
        status = EX_OSERR;
385
 
      }
386
 
      goto failure;
 
320
      perror("sigaction");
 
321
      free(prompt);
 
322
      return EXIT_FAILURE;
387
323
    }
388
324
    if(old_action.sa_handler != SIG_IGN){
389
325
      ret = sigaction(SIGTERM, &new_action, NULL);
390
326
      if(ret == -1){
391
 
        if(errno != EINTR){
392
 
          error(0, errno, "sigaction");
393
 
          status = EX_OSERR;
394
 
        }
395
 
        goto failure;
 
327
        perror("sigaction");
 
328
        free(prompt);
 
329
        return EXIT_FAILURE;
396
330
      }
397
331
    }
398
332
  }
399
333
  
400
 
  usplash_accessed = true;
401
334
  /* 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
 
  
 
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
  }
426
349
  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);
 
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)));
451
463
      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
 
  
 
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
  }
579
475
  /* Kill old usplash */
580
476
  kill(usplash_pid, SIGTERM);
581
477
  sleep(2);
583
479
    kill(usplash_pid, SIGKILL);
584
480
    sleep(1);
585
481
  }
586
 
  
587
482
  pid_t new_usplash_pid = fork();
588
483
  if(new_usplash_pid == 0){
589
484
    /* Child; will become new usplash process */
590
485
    
591
486
    /* Make the effective user ID (root) the only user ID instead of
592
 
       the real user ID (_mandos) */
 
487
       the real user ID (mandos) */
593
488
    ret = setuid(geteuid());
594
489
    if(ret == -1){
595
 
      error(0, errno, "setuid");
 
490
      perror("setuid");
596
491
    }
597
492
    
598
493
    setsid();
599
494
    ret = chdir("/");
600
 
    if(ret == -1){
601
 
      error(0, errno, "chdir");
602
 
      _exit(EX_OSERR);
603
 
    }
604
495
/*     if(fork() != 0){ */
605
496
/*       _exit(EXIT_SUCCESS); */
606
497
/*     } */
607
498
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
608
499
    if(ret == -1){
609
 
      error(0, errno, "dup2");
610
 
      _exit(EX_OSERR);
 
500
      perror("dup2");
 
501
      _exit(EXIT_FAILURE);
611
502
    }
612
503
    
613
504
    execv(usplash_name, cmdline_argv);
614
505
    if(not interrupted_by_signal){
615
 
      error(0, errno, "execv");
 
506
      perror("execv");
616
507
    }
617
508
    free(cmdline);
618
509
    free(cmdline_argv);
619
 
    _exit(EX_OSERR);
 
510
    _exit(EXIT_FAILURE);
620
511
  }
621
512
  free(cmdline);
622
513
  free(cmdline_argv);
623
514
  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;
 
515
  if(not usplash_write("PULSATE", NULL)
 
516
     and (errno != EINTR)){
 
517
    perror("usplash_write");
 
518
  }
 
519
  
 
520
  return EXIT_FAILURE;
658
521
}