/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: 2019-08-05 21:14:05 UTC
  • mto: This revision was merged to the branch mainline in revision 388.
  • Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions

There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version.  We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general.  We prefer the code being there, for the sake of the users.

* debian/mandos-client.lintian-overrides
  (maintainer-script-supports-ancient-package-version): New.
  debian/mandos.lintian-overrides
  (maintainer-script-supports-ancient-package-version): - '' -

Show diffs side-by-side

added added

removed removed

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