/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: 2015-01-25 00:02:51 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150125000251-j2bw50gfq9smqyxe
mandos.xml (SEE ALSO): Update links.

Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).

Show diffs side-by-side

added added

removed removed

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