/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-07-20 03:03:33 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/usplash.c
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
        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
130
  ssize_t sret = 0;
96
 
  while(not interrupted_by_signal and written < cmd_line_len){
97
 
    sret = write(fifo_fd, cmd_line + written,
 
131
  while(written < cmd_line_len){
 
132
    sret = write(*fifo_fd_r, cmd_line + written,
98
133
                 cmd_line_len - written);
99
134
    if(sret == -1){
100
 
      if(errno != EINTR or interrupted_by_signal){
101
 
        int e = errno;
102
 
        close(fifo_fd);
103
 
        free(cmd_line_alloc);
104
 
        errno = e;
105
 
        return false;
106
 
      } else {
107
 
        continue;
108
 
      }
 
135
      int e = errno;
 
136
      close(*fifo_fd_r);
 
137
      free(cmd_line_alloc);
 
138
      errno = e;
 
139
      return false;
109
140
    }
110
141
    written += (size_t)sret;
111
142
  }
112
143
  free(cmd_line_alloc);
113
 
  do{
114
 
    ret = close(fifo_fd);
115
 
    if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
116
 
      return false;
117
 
    }
118
 
  }while(ret == -1);
119
 
  if(interrupted_by_signal){
120
 
    return false;
121
 
  }
 
144
  
122
145
  return true;
123
146
}
124
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
 
125
319
int main(__attribute__((unused))int argc,
126
320
         __attribute__((unused))char **argv){
127
321
  int ret = 0;
128
322
  ssize_t sret;
129
 
  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 */
130
330
  
131
 
  /* Create prompt string */
132
 
  char *prompt = NULL;
133
 
  {
134
 
    const char *const cryptsource = getenv("cryptsource");
135
 
    const char *const crypttarget = getenv("crypttarget");
136
 
    const char prompt_start[] = "Enter passphrase to unlock the disk";
137
 
    
138
 
    if(cryptsource == NULL){
139
 
      if(crypttarget == NULL){
140
 
        ret = asprintf(&prompt, "%s: ", prompt_start);
141
 
      } else {
142
 
        ret = asprintf(&prompt, "%s (%s): ", prompt_start,
143
 
                       crypttarget);
144
 
      }
145
 
    } else {
146
 
      if(crypttarget == NULL){
147
 
        ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
148
 
      } else {
149
 
        ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
150
 
                       cryptsource, crypttarget);
151
 
      }
152
 
    }
153
 
    if(ret == -1){
154
 
      return EXIT_FAILURE;
155
 
    }
 
331
  char *prompt = makeprompt();
 
332
  if(prompt == NULL){
 
333
    status = EX_OSERR;
 
334
    goto failure;
156
335
  }
157
336
  
158
337
  /* Find usplash process */
159
 
  pid_t usplash_pid = 0;
160
338
  char *cmdline = NULL;
161
339
  size_t cmdline_len = 0;
162
 
  const char usplash_name[] = "/sbin/usplash";
163
 
  {
164
 
    DIR *proc_dir = opendir("/proc");
165
 
    if(proc_dir == NULL){
166
 
      free(prompt);
167
 
      perror("opendir");
168
 
      return EXIT_FAILURE;
169
 
    }
170
 
    for(struct dirent *proc_ent = readdir(proc_dir);
171
 
        proc_ent != NULL;
172
 
        proc_ent = readdir(proc_dir)){
173
 
      pid_t pid = (pid_t) strtoul(proc_ent->d_name, NULL, 10);
174
 
      if(pid == 0){
175
 
        /* Not a process */
176
 
        continue;
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
 
          perror("asprintf");
187
 
          free(prompt);
188
 
          closedir(proc_dir);
189
 
          return EXIT_FAILURE;
190
 
        }
191
 
        
192
 
        /* Check that it refers to a symlink owned by root:root */
193
 
        struct stat exe_stat;
194
 
        ret = lstat(exe_link, &exe_stat);
195
 
        if(ret == -1){
196
 
          perror("lstat");
197
 
          free(exe_link);
198
 
          free(prompt);
199
 
          closedir(proc_dir);
200
 
          return EXIT_FAILURE;
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
 
        if(sret == -1){
212
 
          continue;
213
 
        }
214
 
      }
215
 
      if((sret == ((ssize_t)sizeof(exe_target)-1))
216
 
         and (memcmp(usplash_name, exe_target,
217
 
                     sizeof(exe_target)-1) == 0)){
218
 
        usplash_pid = pid;
219
 
        /* Read and save the command line of usplash in "cmdline" */
220
 
        {
221
 
          /* Open /proc/<pid>/cmdline  */
222
 
          int cl_fd;
223
 
          {
224
 
            char *cmdline_filename;
225
 
            ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
226
 
                           proc_ent->d_name);
227
 
            if(ret == -1){
228
 
              perror("asprintf");
229
 
              free(prompt);
230
 
              closedir(proc_dir);
231
 
              return EXIT_FAILURE;
232
 
            }
233
 
            cl_fd = open(cmdline_filename, O_RDONLY);
234
 
            if(cl_fd == -1){
235
 
              perror("open");
236
 
              free(cmdline_filename);
237
 
              free(prompt);
238
 
              closedir(proc_dir);
239
 
              return EXIT_FAILURE;
240
 
            }
241
 
            free(cmdline_filename);
242
 
          }
243
 
          size_t cmdline_allocated = 0;
244
 
          char *tmp;
245
 
          const size_t blocksize = 1024;
246
 
          do{
247
 
            if(cmdline_len + blocksize > cmdline_allocated){
248
 
              tmp = realloc(cmdline, cmdline_allocated + blocksize);
249
 
              if(tmp == NULL){
250
 
                perror("realloc");
251
 
                free(cmdline);
252
 
                free(prompt);
253
 
                closedir(proc_dir);
254
 
                return EXIT_FAILURE;
255
 
              }
256
 
              cmdline = tmp;
257
 
              cmdline_allocated += blocksize;
258
 
            }
259
 
            sret = read(cl_fd, cmdline + cmdline_len,
260
 
                        cmdline_allocated - cmdline_len);
261
 
            if(sret == -1){
262
 
              perror("read");
263
 
              free(cmdline);
264
 
              free(prompt);
265
 
              closedir(proc_dir);
266
 
              return EXIT_FAILURE;
267
 
            }
268
 
            cmdline_len += (size_t)sret;
269
 
          } while(sret != 0);
270
 
          close(cl_fd);
271
 
        }
272
 
        break;
273
 
      }
274
 
    }
275
 
    closedir(proc_dir);
276
 
  }
 
340
  usplash_pid = find_usplash(&cmdline, &cmdline_len);
277
341
  if(usplash_pid == 0){
278
 
    free(prompt);
279
 
    return EXIT_FAILURE;
 
342
    status = EX_UNAVAILABLE;
 
343
    goto failure;
280
344
  }
281
345
  
282
346
  /* Set up the signal handler */
285
349
      new_action = { .sa_handler = termination_handler,
286
350
                     .sa_flags = 0 };
287
351
    sigemptyset(&new_action.sa_mask);
288
 
    sigaddset(&new_action.sa_mask, SIGINT);
289
 
    sigaddset(&new_action.sa_mask, SIGHUP);
290
 
    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
    }
291
370
    ret = sigaction(SIGINT, NULL, &old_action);
292
371
    if(ret == -1){
293
 
      perror("sigaction");
294
 
      free(prompt);
295
 
      return EXIT_FAILURE;
 
372
      if(errno != EINTR){
 
373
        error_plus(0, errno, "sigaction");
 
374
        status = EX_OSERR;
 
375
      }
 
376
      goto failure;
296
377
    }
297
378
    if(old_action.sa_handler != SIG_IGN){
298
379
      ret = sigaction(SIGINT, &new_action, NULL);
299
380
      if(ret == -1){
300
 
        perror("sigaction");
301
 
        free(prompt);
302
 
        return EXIT_FAILURE;
 
381
        if(errno != EINTR){
 
382
          error_plus(0, errno, "sigaction");
 
383
          status = EX_OSERR;
 
384
        }
 
385
        goto failure;
303
386
      }
304
387
    }
305
388
    ret = sigaction(SIGHUP, NULL, &old_action);
306
389
    if(ret == -1){
307
 
      perror("sigaction");
308
 
      free(prompt);
309
 
      return EXIT_FAILURE;
 
390
      if(errno != EINTR){
 
391
        error_plus(0, errno, "sigaction");
 
392
        status = EX_OSERR;
 
393
      }
 
394
      goto failure;
310
395
    }
311
396
    if(old_action.sa_handler != SIG_IGN){
312
397
      ret = sigaction(SIGHUP, &new_action, NULL);
313
398
      if(ret == -1){
314
 
        perror("sigaction");
315
 
        free(prompt);
316
 
        return EXIT_FAILURE;
 
399
        if(errno != EINTR){
 
400
          error_plus(0, errno, "sigaction");
 
401
          status = EX_OSERR;
 
402
        }
 
403
        goto failure;
317
404
      }
318
405
    }
319
406
    ret = sigaction(SIGTERM, NULL, &old_action);
320
407
    if(ret == -1){
321
 
      perror("sigaction");
322
 
      free(prompt);
323
 
      return EXIT_FAILURE;
 
408
      if(errno != EINTR){
 
409
        error_plus(0, errno, "sigaction");
 
410
        status = EX_OSERR;
 
411
      }
 
412
      goto failure;
324
413
    }
325
414
    if(old_action.sa_handler != SIG_IGN){
326
415
      ret = sigaction(SIGTERM, &new_action, NULL);
327
416
      if(ret == -1){
328
 
        perror("sigaction");
329
 
        free(prompt);
330
 
        return EXIT_FAILURE;
 
417
        if(errno != EINTR){
 
418
          error_plus(0, errno, "sigaction");
 
419
          status = EX_OSERR;
 
420
        }
 
421
        goto failure;
331
422
      }
332
423
    }
333
424
  }
334
425
  
 
426
  usplash_accessed = true;
335
427
  /* Write command to FIFO */
336
 
  if(not interrupted_by_signal){
337
 
    if(not usplash_write("TIMEOUT", "0")
338
 
       and (errno != EINTR)){
339
 
      perror("usplash_write");
340
 
      an_error_occured = true;
341
 
    }
342
 
  }
343
 
  if(not interrupted_by_signal and not an_error_occured){
344
 
    if(not usplash_write("INPUTQUIET", prompt)
345
 
       and (errno != EINTR)){
346
 
      perror("usplash_write");
347
 
      an_error_occured = true;
348
 
    }
349
 
  }
 
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
  
350
452
  free(prompt);
351
 
  
352
 
  /* This is not really a loop; while() is used to be able to "break"
353
 
     out of it; those breaks are marked "Big" */
354
 
  while(not interrupted_by_signal and not an_error_occured){
355
 
    char *buf = NULL;
356
 
    size_t buf_len = 0;
357
 
    
358
 
    /* Open FIFO */
359
 
    int fifo_fd;
360
 
    do{
361
 
      fifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
362
 
      if(fifo_fd == -1){
363
 
        if(errno != EINTR){
364
 
          perror("open");
365
 
          an_error_occured = true;
366
 
          break;
367
 
        }
368
 
        if(interrupted_by_signal){
369
 
          break;
370
 
        }
371
 
      }
372
 
    }while(fifo_fd == -1);
373
 
    if(interrupted_by_signal or an_error_occured){
374
 
      break;                    /* Big */
375
 
    }
376
 
    
377
 
    /* Read from FIFO */
378
 
    size_t buf_allocated = 0;
379
 
    const size_t blocksize = 1024;
380
 
    do{
381
 
      if(buf_len + blocksize > buf_allocated){
382
 
        char *tmp = realloc(buf, buf_allocated + blocksize);
383
 
        if(tmp == NULL){
384
 
          perror("realloc");
385
 
          an_error_occured = true;
386
 
          break;
387
 
        }
388
 
        buf = tmp;
389
 
        buf_allocated += blocksize;
390
 
      }
391
 
      do{
392
 
        sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
393
 
        if(sret == -1){
394
 
          if(errno != EINTR){
395
 
            perror("read");
396
 
            an_error_occured = true;
397
 
            break;
398
 
          }
399
 
          if(interrupted_by_signal){
400
 
            break;
401
 
          }
402
 
        }
403
 
      }while(sret == -1);
404
 
      if(interrupted_by_signal or an_error_occured){
405
 
        break;
406
 
      }
407
 
      
408
 
      buf_len += (size_t)sret;
409
 
    }while(sret != 0);
410
 
    close(fifo_fd);
411
 
    if(interrupted_by_signal or an_error_occured){
412
 
      break;                    /* Big */
413
 
    }
414
 
    
415
 
    if(not usplash_write("TIMEOUT", "15")
416
 
       and (errno != EINTR)){
417
 
        perror("usplash_write");
418
 
        an_error_occured = true;
419
 
    }
420
 
    if(interrupted_by_signal or an_error_occured){
421
 
      break;                    /* Big */
422
 
    }
423
 
    
424
 
    /* Print password to stdout */
425
 
    size_t written = 0;
426
 
    while(written < buf_len){
427
 
      do{
428
 
        sret = write(STDOUT_FILENO, buf + written, buf_len - written);
429
 
        if(sret == -1){
430
 
          if(errno != EINTR){
431
 
            perror("write");
432
 
            an_error_occured = true;
433
 
            break;
434
 
          }
435
 
          if(interrupted_by_signal){
436
 
            break;
437
 
          }
438
 
        }
439
 
      }while(sret == -1);
440
 
      if(interrupted_by_signal or an_error_occured){
441
 
        break;
442
 
      }
443
 
      written += (size_t)sret;
444
 
    }
445
 
    free(buf);
446
 
    if(not interrupted_by_signal and not an_error_occured){
447
 
      free(cmdline);
448
 
      return EXIT_SUCCESS;
449
 
    }
450
 
    break;                      /* Big */
451
 
  }                             /* end of non-loop while() */
452
 
  
453
 
  /* If we got here, an error or interrupt must have happened */
454
 
  
455
 
  /* Create argc and argv for new usplash*/
456
 
  int cmdline_argc = 0;
457
 
  char **cmdline_argv = malloc(sizeof(char *));
458
 
  {
459
 
    size_t position = 0;
460
 
    while(position < cmdline_len){
461
 
      char **tmp = realloc(cmdline_argv,
462
 
                           (sizeof(char *)
463
 
                            * (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);
464
477
      if(tmp == NULL){
465
 
        perror("realloc");
466
 
        free(cmdline_argv);
467
 
        return EXIT_FAILURE;
468
 
      }
469
 
      cmdline_argv = tmp;
470
 
      cmdline_argv[cmdline_argc] = cmdline + position;
471
 
      cmdline_argc++;
472
 
      position += strlen(cmdline + position) + 1;
473
 
    }
474
 
    cmdline_argv[cmdline_argc] = NULL;
475
 
  }
 
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
      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 = 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 = 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
  
476
605
  /* Kill old usplash */
477
606
  kill(usplash_pid, SIGTERM);
478
607
  sleep(2);
480
609
    kill(usplash_pid, SIGKILL);
481
610
    sleep(1);
482
611
  }
 
612
  
483
613
  pid_t new_usplash_pid = fork();
484
614
  if(new_usplash_pid == 0){
485
615
    /* Child; will become new usplash process */
486
616
    
487
617
    /* Make the effective user ID (root) the only user ID instead of
488
 
       the real user ID (mandos) */
 
618
       the real user ID (_mandos) */
489
619
    ret = setuid(geteuid());
490
620
    if(ret == -1){
491
 
      perror("setuid");
 
621
      error_plus(0, errno, "setuid");
492
622
    }
493
623
    
494
624
    setsid();
495
625
    ret = chdir("/");
 
626
    if(ret == -1){
 
627
      error_plus(0, errno, "chdir");
 
628
      _exit(EX_OSERR);
 
629
    }
496
630
/*     if(fork() != 0){ */
497
631
/*       _exit(EXIT_SUCCESS); */
498
632
/*     } */
499
633
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
500
634
    if(ret == -1){
501
 
      perror("dup2");
502
 
      _exit(EXIT_FAILURE);
 
635
      error_plus(0, errno, "dup2");
 
636
      _exit(EX_OSERR);
503
637
    }
504
638
    
505
639
    execv(usplash_name, cmdline_argv);
506
640
    if(not interrupted_by_signal){
507
 
      perror("execv");
 
641
      error_plus(0, errno, "execv");
508
642
    }
509
643
    free(cmdline);
510
644
    free(cmdline_argv);
511
 
    _exit(EXIT_FAILURE);
 
645
    _exit(EX_OSERR);
512
646
  }
513
647
  free(cmdline);
514
648
  free(cmdline_argv);
515
649
  sleep(2);
516
 
  if(not usplash_write("PULSATE", NULL)
517
 
     and (errno != EINTR)){
518
 
    perror("usplash_write");
519
 
  }
520
 
  
521
 
  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 = 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;
522
684
}