/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-02-10 03:50:20 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 370.
  • Revision ID: teddy@recompile.se-20190210035020-nttr1tybgwwixueu
http://bugs.debian.org/879538
http://bugs.debian.org/916673
Show debconf note about new TLS key IDs

If mandos-client did not see TLS keys and had to create them, or if
mandos sees GnuTLS version 3.6.6 or later, show an important notice on
package installation about the importance of adding the new key_id
options to clients.conf on the Mandos server.

* debian/control (Package: mandos, Package: mandos-client): Depend on
                                                            debconf.
* debian/mandos-client.lintian-overrides: Override warnings.
* debian/mandos-client.postinst (create_keys): Show notice if new TLS
                                               key files were created.
* debian/mandos-client.templates: New.
* debian/mandos.lintian-overrides: Override warnings.
* debian/mandos.postinst (configure): If GnuTLS 3.6.6 or later is
                                      detected, show an important
                                      notice (once) about the new
                                      key_id option required in
                                      clients.conf.
* debian/mandos.templates: New.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/usplash.c
2
2
/*
3
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
7
 
 * 
8
 
 * This program is free software: you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation, either version 3 of the
11
 
 * License, or (at your option) any later version.
12
 
 * 
13
 
 * This program is distributed in the hope that it will be useful, but
 
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
14
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
18
 * General Public License for more details.
17
19
 * 
18
20
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
21
22
 * 
22
 
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
23
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
23
 * Contact the authors at <mandos@recompile.se>.
24
24
 */
25
25
 
26
 
#define _GNU_SOURCE             /* asprintf() */
 
26
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
27
27
#include <signal.h>             /* sig_atomic_t, struct sigaction,
28
28
                                   sigemptyset(), sigaddset(), SIGINT,
29
29
                                   SIGHUP, SIGTERM, sigaction(),
32
32
#include <fcntl.h>              /* open(), O_WRONLY, O_RDONLY */
33
33
#include <iso646.h>             /* and, or, not*/
34
34
#include <errno.h>              /* errno, EINTR */
 
35
#include <error.h>
35
36
#include <sys/types.h>          /* size_t, ssize_t, pid_t, DIR, struct
36
37
                                   dirent */
37
38
#include <stddef.h>             /* NULL */
38
 
#include <string.h>             /* strlen(), memcmp() */
39
 
#include <stdio.h>              /* asprintf(), perror(), sscanf() */
 
39
#include <string.h>             /* strlen(), memcmp(), strerror() */
 
40
#include <stdio.h>              /* asprintf(), vasprintf(), vprintf(),
 
41
                                   fprintf() */
40
42
#include <unistd.h>             /* close(), write(), readlink(),
41
43
                                   read(), STDOUT_FILENO, sleep(),
42
44
                                   fork(), setuid(), geteuid(),
43
45
                                   setsid(), chdir(), dup2(),
44
46
                                   STDERR_FILENO, execv() */
45
47
#include <stdlib.h>             /* free(), EXIT_FAILURE, realloc(),
46
 
                                   EXIT_SUCCESS, malloc(), _exit() */
47
 
#include <stdlib.h>             /* getenv() */
 
48
                                   EXIT_SUCCESS, malloc(), _exit(),
 
49
                                   getenv() */
48
50
#include <dirent.h>             /* opendir(), readdir(), closedir() */
49
 
#include <inttypes.h>           /* intmax_t, SCNdMAX */
 
51
#include <inttypes.h>           /* intmax_t, strtoimax() */
50
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(), ... */
51
56
 
52
57
sig_atomic_t interrupted_by_signal = 0;
53
 
 
54
 
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
  }
55
89
  interrupted_by_signal = 1;
 
90
  signal_received = signum;
56
91
}
57
92
 
58
 
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){
59
95
  /* 
60
 
   * usplash_write("TIMEOUT", "15") will write "TIMEOUT 15\0"
61
 
   * usplash_write("PULSATE", NULL) will write "PULSATE\0"
 
96
   * usplash_write(&fd, "TIMEOUT", "15") will write "TIMEOUT 15\0"
 
97
   * usplash_write(&fd, "PULSATE", NULL) will write "PULSATE\0"
62
98
   * SEE ALSO
63
99
   *         usplash_write(8)
64
100
   */
65
101
  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)){
 
102
  if(*fifo_fd_r == -1){
 
103
    ret = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
 
104
    if(ret == -1){
70
105
      return false;
71
106
    }
72
 
  }while(fifo_fd == -1);
 
107
    *fifo_fd_r = ret;
 
108
  }
73
109
  
74
110
  const char *cmd_line;
75
111
  size_t cmd_line_len;
76
112
  char *cmd_line_alloc = NULL;
77
113
  if(arg == NULL){
78
114
    cmd_line = cmd;
79
 
    cmd_line_len = strlen(cmd);
80
 
  }else{
81
 
    do{
 
115
    cmd_line_len = strlen(cmd) + 1;
 
116
  } else {
 
117
    do {
82
118
      ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
83
 
      if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
 
119
      if(ret == -1){
84
120
        int e = errno;
85
 
        close(fifo_fd);
 
121
        close(*fifo_fd_r);
86
122
        errno = e;
87
123
        return false;
88
124
      }
89
 
    }while(ret == -1);
 
125
    } while(ret == -1);
90
126
    cmd_line = cmd_line_alloc;
91
127
    cmd_line_len = (size_t)ret + 1;
92
128
  }
93
129
  
94
130
  size_t written = 0;
95
131
  ssize_t sret = 0;
96
 
  while(not interrupted_by_signal and written < cmd_line_len){
97
 
    sret = write(fifo_fd, cmd_line + written,
 
132
  while(written < cmd_line_len){
 
133
    sret = write(*fifo_fd_r, cmd_line + written,
98
134
                 cmd_line_len - written);
99
135
    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
 
      }
 
136
      int e = errno;
 
137
      close(*fifo_fd_r);
 
138
      free(cmd_line_alloc);
 
139
      errno = e;
 
140
      return false;
109
141
    }
110
142
    written += (size_t)sret;
111
143
  }
112
144
  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
 
  }
 
145
  
122
146
  return true;
123
147
}
124
148
 
 
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;
 
181
  char *cmdline = NULL;
 
182
  size_t cmdline_len = 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){
 
199
        /* Not a process */
 
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;
 
251
      {
 
252
        char *cmdline_filename;
 
253
        ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
254
                       proc_ent->d_name);
 
255
        if(ret == -1){
 
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
        }
 
265
      }
 
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;
 
277
          }
 
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");
 
286
          close(cl_fd);
 
287
          goto fail_find_usplash;
 
288
        }
 
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;
 
295
      }
 
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;
 
314
    closedir(proc_dir);
 
315
    errno = e;
 
316
  }
 
317
  return 0;
 
318
}
 
319
 
125
320
int main(__attribute__((unused))int argc,
126
321
         __attribute__((unused))char **argv){
127
322
  int ret = 0;
128
323
  ssize_t sret;
129
 
  bool an_error_occured = false;
 
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 */
130
331
  
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
 
    }
 
332
  char *prompt = makeprompt();
 
333
  if(prompt == NULL){
 
334
    status = EX_OSERR;
 
335
    goto failure;
156
336
  }
157
337
  
158
338
  /* Find usplash process */
159
 
  pid_t usplash_pid = 0;
160
339
  char *cmdline = NULL;
161
340
  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;
174
 
      {
175
 
        intmax_t tmpmax;
176
 
        int numchars;
177
 
        ret = sscanf(proc_ent->d_name, "%" SCNdMAX "%n", &tmpmax,
178
 
                     &numchars);
179
 
        if(ret < 1 or tmpmax != (pid_t)tmpmax
180
 
           or proc_ent->d_name[numchars] != '\0'){
181
 
          /* Not a process */
182
 
          continue;
183
 
        }
184
 
        pid = (pid_t)tmpmax;
185
 
      }
186
 
      /* Find the executable name by doing readlink() on the
187
 
         /proc/<pid>/exe link */
188
 
      char exe_target[sizeof(usplash_name)];
189
 
      {
190
 
        /* create file name string */
191
 
        char *exe_link;
192
 
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
193
 
        if(ret == -1){
194
 
          perror("asprintf");
195
 
          free(prompt);
196
 
          closedir(proc_dir);
197
 
          return EXIT_FAILURE;
198
 
        }
199
 
        
200
 
        /* Check that it refers to a symlink owned by root:root */
201
 
        struct stat exe_stat;
202
 
        ret = lstat(exe_link, &exe_stat);
203
 
        if(ret == -1){
204
 
          if(errno == ENOENT){
205
 
            free(exe_link);
206
 
            continue;
207
 
          }
208
 
          perror("lstat");
209
 
          free(exe_link);
210
 
          free(prompt);
211
 
          closedir(proc_dir);
212
 
          return EXIT_FAILURE;
213
 
        }
214
 
        if(not S_ISLNK(exe_stat.st_mode)
215
 
           or exe_stat.st_uid != 0
216
 
           or exe_stat.st_gid != 0){
217
 
          free(exe_link);
218
 
          continue;
219
 
        }
220
 
        
221
 
        sret = readlink(exe_link, exe_target, sizeof(exe_target));
222
 
        free(exe_link);
223
 
      }
224
 
      if((sret == ((ssize_t)sizeof(exe_target)-1))
225
 
         and (memcmp(usplash_name, exe_target,
226
 
                     sizeof(exe_target)-1) == 0)){
227
 
        usplash_pid = pid;
228
 
        /* Read and save the command line of usplash in "cmdline" */
229
 
        {
230
 
          /* Open /proc/<pid>/cmdline  */
231
 
          int cl_fd;
232
 
          {
233
 
            char *cmdline_filename;
234
 
            ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
235
 
                           proc_ent->d_name);
236
 
            if(ret == -1){
237
 
              perror("asprintf");
238
 
              free(prompt);
239
 
              closedir(proc_dir);
240
 
              return EXIT_FAILURE;
241
 
            }
242
 
            cl_fd = open(cmdline_filename, O_RDONLY);
243
 
            if(cl_fd == -1){
244
 
              perror("open");
245
 
              free(cmdline_filename);
246
 
              free(prompt);
247
 
              closedir(proc_dir);
248
 
              return EXIT_FAILURE;
249
 
            }
250
 
            free(cmdline_filename);
251
 
          }
252
 
          size_t cmdline_allocated = 0;
253
 
          char *tmp;
254
 
          const size_t blocksize = 1024;
255
 
          do{
256
 
            if(cmdline_len + blocksize > cmdline_allocated){
257
 
              tmp = realloc(cmdline, cmdline_allocated + blocksize);
258
 
              if(tmp == NULL){
259
 
                perror("realloc");
260
 
                free(cmdline);
261
 
                free(prompt);
262
 
                closedir(proc_dir);
263
 
                return EXIT_FAILURE;
264
 
              }
265
 
              cmdline = tmp;
266
 
              cmdline_allocated += blocksize;
267
 
            }
268
 
            sret = read(cl_fd, cmdline + cmdline_len,
269
 
                        cmdline_allocated - cmdline_len);
270
 
            if(sret == -1){
271
 
              perror("read");
272
 
              free(cmdline);
273
 
              free(prompt);
274
 
              closedir(proc_dir);
275
 
              return EXIT_FAILURE;
276
 
            }
277
 
            cmdline_len += (size_t)sret;
278
 
          } while(sret != 0);
279
 
          close(cl_fd);
280
 
        }
281
 
        break;
282
 
      }
283
 
    }
284
 
    closedir(proc_dir);
285
 
  }
 
341
  usplash_pid = find_usplash(&cmdline, &cmdline_len);
286
342
  if(usplash_pid == 0){
287
 
    free(prompt);
288
 
    return EXIT_FAILURE;
 
343
    status = EX_UNAVAILABLE;
 
344
    goto failure;
289
345
  }
290
346
  
291
347
  /* Set up the signal handler */
294
350
      new_action = { .sa_handler = termination_handler,
295
351
                     .sa_flags = 0 };
296
352
    sigemptyset(&new_action.sa_mask);
297
 
    sigaddset(&new_action.sa_mask, SIGINT);
298
 
    sigaddset(&new_action.sa_mask, SIGHUP);
299
 
    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
    }
300
371
    ret = sigaction(SIGINT, NULL, &old_action);
301
372
    if(ret == -1){
302
 
      perror("sigaction");
303
 
      free(prompt);
304
 
      return EXIT_FAILURE;
 
373
      if(errno != EINTR){
 
374
        error_plus(0, errno, "sigaction");
 
375
        status = EX_OSERR;
 
376
      }
 
377
      goto failure;
305
378
    }
306
379
    if(old_action.sa_handler != SIG_IGN){
307
380
      ret = sigaction(SIGINT, &new_action, NULL);
308
381
      if(ret == -1){
309
 
        perror("sigaction");
310
 
        free(prompt);
311
 
        return EXIT_FAILURE;
 
382
        if(errno != EINTR){
 
383
          error_plus(0, errno, "sigaction");
 
384
          status = EX_OSERR;
 
385
        }
 
386
        goto failure;
312
387
      }
313
388
    }
314
389
    ret = sigaction(SIGHUP, NULL, &old_action);
315
390
    if(ret == -1){
316
 
      perror("sigaction");
317
 
      free(prompt);
318
 
      return EXIT_FAILURE;
 
391
      if(errno != EINTR){
 
392
        error_plus(0, errno, "sigaction");
 
393
        status = EX_OSERR;
 
394
      }
 
395
      goto failure;
319
396
    }
320
397
    if(old_action.sa_handler != SIG_IGN){
321
398
      ret = sigaction(SIGHUP, &new_action, NULL);
322
399
      if(ret == -1){
323
 
        perror("sigaction");
324
 
        free(prompt);
325
 
        return EXIT_FAILURE;
 
400
        if(errno != EINTR){
 
401
          error_plus(0, errno, "sigaction");
 
402
          status = EX_OSERR;
 
403
        }
 
404
        goto failure;
326
405
      }
327
406
    }
328
407
    ret = sigaction(SIGTERM, NULL, &old_action);
329
408
    if(ret == -1){
330
 
      perror("sigaction");
331
 
      free(prompt);
332
 
      return EXIT_FAILURE;
 
409
      if(errno != EINTR){
 
410
        error_plus(0, errno, "sigaction");
 
411
        status = EX_OSERR;
 
412
      }
 
413
      goto failure;
333
414
    }
334
415
    if(old_action.sa_handler != SIG_IGN){
335
416
      ret = sigaction(SIGTERM, &new_action, NULL);
336
417
      if(ret == -1){
337
 
        perror("sigaction");
338
 
        free(prompt);
339
 
        return EXIT_FAILURE;
 
418
        if(errno != EINTR){
 
419
          error_plus(0, errno, "sigaction");
 
420
          status = EX_OSERR;
 
421
        }
 
422
        goto failure;
340
423
      }
341
424
    }
342
425
  }
343
426
  
 
427
  usplash_accessed = true;
344
428
  /* Write command to FIFO */
345
 
  if(not interrupted_by_signal){
346
 
    if(not usplash_write("TIMEOUT", "0")
347
 
       and (errno != EINTR)){
348
 
      perror("usplash_write");
349
 
      an_error_occured = true;
350
 
    }
351
 
  }
352
 
  if(not interrupted_by_signal and not an_error_occured){
353
 
    if(not usplash_write("INPUTQUIET", prompt)
354
 
       and (errno != EINTR)){
355
 
      perror("usplash_write");
356
 
      an_error_occured = true;
357
 
    }
358
 
  }
 
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
  
359
453
  free(prompt);
360
 
  
361
 
  /* This is not really a loop; while() is used to be able to "break"
362
 
     out of it; those breaks are marked "Big" */
363
 
  while(not interrupted_by_signal and not an_error_occured){
364
 
    char *buf = NULL;
365
 
    size_t buf_len = 0;
366
 
    
367
 
    /* Open FIFO */
368
 
    int fifo_fd;
369
 
    do{
370
 
      fifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
371
 
      if(fifo_fd == -1){
372
 
        if(errno != EINTR){
373
 
          perror("open");
374
 
          an_error_occured = true;
375
 
          break;
376
 
        }
377
 
        if(interrupted_by_signal){
378
 
          break;
379
 
        }
380
 
      }
381
 
    }while(fifo_fd == -1);
382
 
    if(interrupted_by_signal or an_error_occured){
383
 
      break;                    /* Big */
384
 
    }
385
 
    
386
 
    /* Read from FIFO */
387
 
    size_t buf_allocated = 0;
388
 
    const size_t blocksize = 1024;
389
 
    do{
390
 
      if(buf_len + blocksize > buf_allocated){
391
 
        char *tmp = realloc(buf, buf_allocated + blocksize);
392
 
        if(tmp == NULL){
393
 
          perror("realloc");
394
 
          an_error_occured = true;
395
 
          break;
396
 
        }
397
 
        buf = tmp;
398
 
        buf_allocated += blocksize;
399
 
      }
400
 
      do{
401
 
        sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
402
 
        if(sret == -1){
403
 
          if(errno != EINTR){
404
 
            perror("read");
405
 
            an_error_occured = true;
406
 
            break;
407
 
          }
408
 
          if(interrupted_by_signal){
409
 
            break;
410
 
          }
411
 
        }
412
 
      }while(sret == -1);
413
 
      if(interrupted_by_signal or an_error_occured){
414
 
        break;
415
 
      }
416
 
      
417
 
      buf_len += (size_t)sret;
418
 
    }while(sret != 0);
419
 
    close(fifo_fd);
420
 
    if(interrupted_by_signal or an_error_occured){
421
 
      break;                    /* Big */
422
 
    }
423
 
    
424
 
    if(not usplash_write("TIMEOUT", "15")
425
 
       and (errno != EINTR)){
426
 
        perror("usplash_write");
427
 
        an_error_occured = true;
428
 
    }
429
 
    if(interrupted_by_signal or an_error_occured){
430
 
      break;                    /* Big */
431
 
    }
432
 
    
433
 
    /* Print password to stdout */
434
 
    size_t written = 0;
435
 
    while(written < buf_len){
436
 
      do{
437
 
        sret = write(STDOUT_FILENO, buf + written, buf_len - written);
438
 
        if(sret == -1){
439
 
          if(errno != EINTR){
440
 
            perror("write");
441
 
            an_error_occured = true;
442
 
            break;
443
 
          }
444
 
          if(interrupted_by_signal){
445
 
            break;
446
 
          }
447
 
        }
448
 
      }while(sret == -1);
449
 
      if(interrupted_by_signal or an_error_occured){
450
 
        break;
451
 
      }
452
 
      written += (size_t)sret;
453
 
    }
454
 
    free(buf);
455
 
    if(not interrupted_by_signal and not an_error_occured){
456
 
      free(cmdline);
457
 
      return EXIT_SUCCESS;
458
 
    }
459
 
    break;                      /* Big */
460
 
  }                             /* end of non-loop while() */
461
 
  
462
 
  /* If we got here, an error or interrupt must have happened */
463
 
  
464
 
  /* Create argc and argv for new usplash*/
465
 
  int cmdline_argc = 0;
466
 
  char **cmdline_argv = malloc(sizeof(char *));
467
 
  {
468
 
    size_t position = 0;
469
 
    while(position < cmdline_len){
470
 
      char **tmp = realloc(cmdline_argv,
471
 
                           (sizeof(char *)
472
 
                            * (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);
473
478
      if(tmp == NULL){
474
 
        perror("realloc");
475
 
        free(cmdline_argv);
476
 
        return EXIT_FAILURE;
477
 
      }
478
 
      cmdline_argv = tmp;
479
 
      cmdline_argv[cmdline_argc] = cmdline + position;
480
 
      cmdline_argc++;
481
 
      position += strlen(cmdline + position) + 1;
482
 
    }
483
 
    cmdline_argv[cmdline_argc] = NULL;
484
 
  }
 
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
  
485
606
  /* Kill old usplash */
486
607
  kill(usplash_pid, SIGTERM);
487
608
  sleep(2);
489
610
    kill(usplash_pid, SIGKILL);
490
611
    sleep(1);
491
612
  }
 
613
  
492
614
  pid_t new_usplash_pid = fork();
493
615
  if(new_usplash_pid == 0){
494
616
    /* Child; will become new usplash process */
497
619
       the real user ID (_mandos) */
498
620
    ret = setuid(geteuid());
499
621
    if(ret == -1){
500
 
      perror("setuid");
 
622
      error_plus(0, errno, "setuid");
501
623
    }
502
624
    
503
625
    setsid();
504
626
    ret = chdir("/");
 
627
    if(ret == -1){
 
628
      error_plus(0, errno, "chdir");
 
629
      _exit(EX_OSERR);
 
630
    }
505
631
/*     if(fork() != 0){ */
506
632
/*       _exit(EXIT_SUCCESS); */
507
633
/*     } */
508
634
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
509
635
    if(ret == -1){
510
 
      perror("dup2");
511
 
      _exit(EXIT_FAILURE);
 
636
      error_plus(0, errno, "dup2");
 
637
      _exit(EX_OSERR);
512
638
    }
513
639
    
514
640
    execv(usplash_name, cmdline_argv);
515
641
    if(not interrupted_by_signal){
516
 
      perror("execv");
 
642
      error_plus(0, errno, "execv");
517
643
    }
518
644
    free(cmdline);
519
645
    free(cmdline_argv);
520
 
    _exit(EXIT_FAILURE);
 
646
    _exit(EX_OSERR);
521
647
  }
522
648
  free(cmdline);
523
649
  free(cmdline_argv);
524
650
  sleep(2);
525
 
  if(not usplash_write("PULSATE", NULL)
526
 
     and (errno != EINTR)){
527
 
    perror("usplash_write");
528
 
  }
529
 
  
530
 
  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;
531
685
}