/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/splashy.c

  • Committer: Teddy Hogeborn
  • Date: 2024-11-17 18:43:11 UTC
  • mto: This revision was merged to the branch mainline in revision 412.
  • Revision ID: teddy@recompile.se-20241117184311-ox25kvngy62h209g
Debian package: Avoid suggesting a C compiler unnecessarily

The list of suggested packages, meant to enable the "mandos" program
to find the correct value of SO_BINDTODEVICE by using a C compiler,
are not necessary when Python 3.3 or later is used, since it has the
SO_BINDTODEVICE constant defined in the "socket" module.  Also, Python
2.6 or older has the same constant in the old "IN" module.  Therefore,
we should suggest these Python versions as alternatives to a C
compiler, so that a C compiler is not installed unnecessarily.

debian/control (Package: mandos/Suggests): Add "python3 (>= 3.3)" and
"python (<= 2.6)" as alternatives to "libc6-dev | libc-dev" and
"c-compiler".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/splashy.c
2
2
/*
3
3
 * Splashy - Read a password from splashy 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, 2021-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2018, 2021-2022 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() */
27
 
#include <signal.h>             /* sig_atomic_t, struct sigaction,
28
 
                                   sigemptyset(), sigaddset(), SIGINT,
29
 
                                   SIGHUP, SIGTERM, sigaction,
30
 
                                   SIG_IGN, kill(), SIGKILL */
 
26
#define _GNU_SOURCE             /* vasprintf(),
 
27
                                   program_invocation_short_name,
 
28
                                   asprintf(), TEMP_FAILURE_RETRY() */
 
29
#include <sys/types.h>          /* sig_atomic_t, pid_t, setuid(),
 
30
                                   geteuid(), setsid() */
 
31
#include <stdarg.h>             /* va_list, va_start(), vfprintf() */
 
32
#include <stdio.h>              /* vasprintf(), fprintf(), stderr,
 
33
                                   vfprintf(), asprintf() */
 
34
#include <errno.h>              /* program_invocation_short_name,
 
35
                                   errno, EACCES, ENOTDIR, ELOOP,
 
36
                                   ENOENT, ENAMETOOLONG, EMFILE,
 
37
                                   ENFILE, ENOMEM, ENOEXEC, EINVAL,
 
38
                                   E2BIG, EFAULT, EIO, ETXTBSY,
 
39
                                   EISDIR, ELIBBAD, EPERM, EINTR,
 
40
                                   ECHILD */
 
41
#include <string.h>             /* strerror(), memcmp() */
 
42
#include <error.h>              /* error() */
 
43
#include <stdlib.h>             /* free(), EXIT_FAILURE, getenv(),
 
44
                                   EXIT_SUCCESS, abort() */
31
45
#include <stddef.h>             /* NULL */
32
 
#include <stdlib.h>             /* getenv() */
33
 
#include <stdio.h>              /* asprintf(), perror(), sscanf() */
34
 
#include <stdlib.h>             /* EXIT_FAILURE, free(),
35
 
                                   EXIT_SUCCESS */
36
 
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
37
 
                                   ssize_t */
38
 
#include <dirent.h>             /* opendir(), readdir(), closedir() */
39
 
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK */
40
 
#include <iso646.h>             /* not, or, and */
41
 
#include <unistd.h>             /* readlink(), fork(), execl(),
42
 
                                   sleep(), dup2() STDERR_FILENO,
43
 
                                   STDOUT_FILENO, _exit() */
44
 
#include <string.h>             /* memcmp() */
45
 
#include <errno.h>              /* errno */
 
46
#include <dirent.h>             /* DIR, opendir(), struct dirent,
 
47
                                   readdir(), closedir() */
 
48
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
 
49
                                   EX_UNAVAILABLE */
 
50
#include <inttypes.h>           /* intmax_t, strtoimax() */
 
51
#include <iso646.h>             /* or, not, and */
 
52
#include <unistd.h>             /* ssize_t, readlink(), fork(),
 
53
                                   execl(), _exit(),
 
54
                                   TEMP_FAILURE_RETRY(), sleep(),
 
55
                                   setuid(), geteuid(), setsid(),
 
56
                                   chdir(), dup2(), STDERR_FILENO,
 
57
                                   STDOUT_FILENO, pause() */
 
58
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK() */
 
59
#include <signal.h>             /* struct sigaction, sigemptyset(),
 
60
                                   sigaddset(), SIGINT, SIGHUP,
 
61
                                   SIGTERM, SIG_IGN, kill(), SIGKILL,
 
62
                                   SIG_DFL, raise() */
46
63
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
47
64
                                   WEXITSTATUS() */
48
65
 
49
66
sig_atomic_t interrupted_by_signal = 0;
50
 
 
51
 
static void termination_handler(__attribute__((unused))int signum){
 
67
int signal_received;
 
68
 
 
69
/* Function to use when printing errors */
 
70
__attribute__((format (gnu_printf, 3, 4)))
 
71
void error_plus(int status, int errnum, const char *formatstring,
 
72
                ...){
 
73
  va_list ap;
 
74
  char *text;
 
75
  int ret;
 
76
  
 
77
  va_start(ap, formatstring);
 
78
  ret = vasprintf(&text, formatstring, ap);
 
79
  if(ret == -1){
 
80
    fprintf(stderr, "Mandos plugin %s: ",
 
81
            program_invocation_short_name);
 
82
    vfprintf(stderr, formatstring, ap);
 
83
    fprintf(stderr, ": ");
 
84
    fprintf(stderr, "%s\n", strerror(errnum));
 
85
    error(status, errno, "vasprintf while printing error");
 
86
    return;
 
87
  }
 
88
  fprintf(stderr, "Mandos plugin ");
 
89
  error(status, errnum, "%s", text);
 
90
  free(text);
 
91
}
 
92
 
 
93
 
 
94
static void termination_handler(int signum){
 
95
  if(interrupted_by_signal){
 
96
    return;
 
97
  }
52
98
  interrupted_by_signal = 1;
 
99
  signal_received = signum;
53
100
}
54
101
 
55
102
int main(__attribute__((unused))int argc,
56
103
         __attribute__((unused))char **argv){
57
104
  int ret = 0;
 
105
  char *prompt = NULL;
 
106
  DIR *proc_dir = NULL;
 
107
  pid_t splashy_pid = 0;
 
108
  pid_t splashy_command_pid = 0;
 
109
  int exitstatus = EXIT_FAILURE;
58
110
  
59
111
  /* Create prompt string */
60
 
  char *prompt = NULL;
61
112
  {
62
113
    const char *const cryptsource = getenv("cryptsource");
63
114
    const char *const crypttarget = getenv("crypttarget");
80
131
      }
81
132
    }
82
133
    if(ret == -1){
83
 
      return EXIT_FAILURE;
 
134
      prompt = NULL;
 
135
      exitstatus = EX_OSERR;
 
136
      goto failure;
84
137
    }
85
138
  }
86
139
  
87
140
  /* Find splashy process */
88
 
  pid_t splashy_pid = 0;
89
141
  {
90
142
    const char splashy_name[] = "/sbin/splashy";
91
 
    DIR *proc_dir = opendir("/proc");
 
143
    proc_dir = opendir("/proc");
92
144
    if(proc_dir == NULL){
93
 
      free(prompt);
94
 
      perror("opendir");
95
 
      return EXIT_FAILURE;
 
145
      int e = errno;
 
146
      error_plus(0, errno, "opendir");
 
147
      switch(e){
 
148
      case EACCES:
 
149
      case ENOTDIR:
 
150
      case ELOOP:
 
151
      case ENOENT:
 
152
      default:
 
153
        exitstatus = EX_OSFILE;
 
154
        break;
 
155
      case ENAMETOOLONG:
 
156
      case EMFILE:
 
157
      case ENFILE:
 
158
      case ENOMEM:
 
159
        exitstatus = EX_OSERR;
 
160
        break;
 
161
      }
 
162
      goto failure;
96
163
    }
97
164
    for(struct dirent *proc_ent = readdir(proc_dir);
98
165
        proc_ent != NULL;
99
166
        proc_ent = readdir(proc_dir)){
100
167
      pid_t pid;
101
 
      /* In the GNU C library, pid_t is always int */
102
 
      ret = sscanf(proc_ent->d_name, "%d", &pid);
103
 
      if(ret != 1){ 
104
 
        /* Not a process */
105
 
        continue;
 
168
      {
 
169
        intmax_t tmpmax;
 
170
        char *tmp;
 
171
        errno = 0;
 
172
        tmpmax = strtoimax(proc_ent->d_name, &tmp, 10);
 
173
        if(errno != 0 or tmp == proc_ent->d_name or *tmp != '\0'
 
174
           or tmpmax != (pid_t)tmpmax){
 
175
          /* Not a process */
 
176
          continue;
 
177
        }
 
178
        pid = (pid_t)tmpmax;
106
179
      }
107
180
      /* Find the executable name by doing readlink() on the
108
181
         /proc/<pid>/exe link */
112
185
        char *exe_link;
113
186
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
114
187
        if(ret == -1){
115
 
          perror("asprintf");
116
 
          free(prompt);
117
 
          closedir(proc_dir);
118
 
          return EXIT_FAILURE;
 
188
          error_plus(0, errno, "asprintf");
 
189
          exitstatus = EX_OSERR;
 
190
          goto failure;
119
191
        }
120
192
        
121
193
        /* Check that it refers to a symlink owned by root:root */
126
198
            free(exe_link);
127
199
            continue;
128
200
          }
129
 
          perror("lstat");
 
201
          int e = errno;
 
202
          error_plus(0, errno, "lstat");
130
203
          free(exe_link);
131
 
          free(prompt);
132
 
          closedir(proc_dir);
133
 
          return EXIT_FAILURE;
 
204
          switch(e){
 
205
          case EACCES:
 
206
          case ENOTDIR:
 
207
          case ELOOP:
 
208
          default:
 
209
            exitstatus = EX_OSFILE;
 
210
            break;
 
211
          case ENAMETOOLONG:
 
212
            exitstatus = EX_OSERR;
 
213
            break;
 
214
          }
 
215
          goto failure;
134
216
        }
135
217
        if(not S_ISLNK(exe_stat.st_mode)
136
218
           or exe_stat.st_uid != 0
150
232
      }
151
233
    }
152
234
    closedir(proc_dir);
 
235
    proc_dir = NULL;
153
236
  }
154
237
  if(splashy_pid == 0){
155
 
    free(prompt);
156
 
    return EXIT_FAILURE;
 
238
    exitstatus = EX_UNAVAILABLE;
 
239
    goto failure;
157
240
  }
158
241
  
159
242
  /* Set up the signal handler */
162
245
      new_action = { .sa_handler = termination_handler,
163
246
                     .sa_flags = 0 };
164
247
    sigemptyset(&new_action.sa_mask);
165
 
    sigaddset(&new_action.sa_mask, SIGINT);
166
 
    sigaddset(&new_action.sa_mask, SIGHUP);
167
 
    sigaddset(&new_action.sa_mask, SIGTERM);
 
248
    ret = sigaddset(&new_action.sa_mask, SIGINT);
 
249
    if(ret == -1){
 
250
      error_plus(0, errno, "sigaddset");
 
251
      exitstatus = EX_OSERR;
 
252
      goto failure;
 
253
    }
 
254
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
 
255
    if(ret == -1){
 
256
      error_plus(0, errno, "sigaddset");
 
257
      exitstatus = EX_OSERR;
 
258
      goto failure;
 
259
    }
 
260
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
 
261
    if(ret == -1){
 
262
      error_plus(0, errno, "sigaddset");
 
263
      exitstatus = EX_OSERR;
 
264
      goto failure;
 
265
    }
168
266
    ret = sigaction(SIGINT, NULL, &old_action);
169
267
    if(ret == -1){
170
 
      perror("sigaction");
171
 
      free(prompt);
172
 
      return EXIT_FAILURE;
 
268
      error_plus(0, errno, "sigaction");
 
269
      exitstatus = EX_OSERR;
 
270
      goto failure;
173
271
    }
174
272
    if(old_action.sa_handler != SIG_IGN){
175
273
      ret = sigaction(SIGINT, &new_action, NULL);
176
274
      if(ret == -1){
177
 
        perror("sigaction");
178
 
        free(prompt);
179
 
        return EXIT_FAILURE;
 
275
        error_plus(0, errno, "sigaction");
 
276
        exitstatus = EX_OSERR;
 
277
        goto failure;
180
278
      }
181
279
    }
182
280
    ret = sigaction(SIGHUP, NULL, &old_action);
183
281
    if(ret == -1){
184
 
      perror("sigaction");
185
 
      free(prompt);
186
 
      return EXIT_FAILURE;
 
282
      error_plus(0, errno, "sigaction");
 
283
      exitstatus = EX_OSERR;
 
284
      goto failure;
187
285
    }
188
286
    if(old_action.sa_handler != SIG_IGN){
189
287
      ret = sigaction(SIGHUP, &new_action, NULL);
190
288
      if(ret == -1){
191
 
        perror("sigaction");
192
 
        free(prompt);
193
 
        return EXIT_FAILURE;
 
289
        error_plus(0, errno, "sigaction");
 
290
        exitstatus = EX_OSERR;
 
291
        goto failure;
194
292
      }
195
293
    }
196
294
    ret = sigaction(SIGTERM, NULL, &old_action);
197
295
    if(ret == -1){
198
 
      perror("sigaction");
199
 
      free(prompt);
200
 
      return EXIT_FAILURE;
 
296
      error_plus(0, errno, "sigaction");
 
297
      exitstatus = EX_OSERR;
 
298
      goto failure;
201
299
    }
202
300
    if(old_action.sa_handler != SIG_IGN){
203
301
      ret = sigaction(SIGTERM, &new_action, NULL);
204
302
      if(ret == -1){
205
 
        perror("sigaction");
206
 
        free(prompt);
207
 
        return EXIT_FAILURE;
 
303
        error_plus(0, errno, "sigaction");
 
304
        exitstatus = EX_OSERR;
 
305
        goto failure;
208
306
      }
209
307
    }
210
308
  }
211
309
  
 
310
  if(interrupted_by_signal){
 
311
    goto failure;
 
312
  }
 
313
  
212
314
  /* Fork off the splashy command to prompt for password */
213
 
  pid_t splashy_command_pid = 0;
214
 
  if(not interrupted_by_signal){
215
 
    splashy_command_pid = fork();
216
 
    if(splashy_command_pid == -1){
217
 
      if(not interrupted_by_signal){
218
 
        perror("fork");
219
 
      }
220
 
      return EXIT_FAILURE;
221
 
    }
222
 
    /* Child */
223
 
    if(splashy_command_pid == 0){
 
315
  splashy_command_pid = fork();
 
316
  if(splashy_command_pid != 0 and interrupted_by_signal){
 
317
    goto failure;
 
318
  }
 
319
  if(splashy_command_pid == -1){
 
320
    error_plus(0, errno, "fork");
 
321
    exitstatus = EX_OSERR;
 
322
    goto failure;
 
323
  }
 
324
  /* Child */
 
325
  if(splashy_command_pid == 0){
 
326
    if(not interrupted_by_signal){
224
327
      const char splashy_command[] = "/sbin/splashy_update";
225
 
      ret = execl(splashy_command, splashy_command, prompt,
226
 
                  (char *)NULL);
227
 
      if(not interrupted_by_signal){
228
 
        perror("execl");
 
328
      execl(splashy_command, splashy_command, prompt, (char *)NULL);
 
329
      int e = errno;
 
330
      error_plus(0, errno, "execl");
 
331
      switch(e){
 
332
      case EACCES:
 
333
      case ENOENT:
 
334
      case ENOEXEC:
 
335
      case EINVAL:
 
336
        _exit(EX_UNAVAILABLE);
 
337
      case ENAMETOOLONG:
 
338
      case E2BIG:
 
339
      case ENOMEM:
 
340
      case EFAULT:
 
341
      case EIO:
 
342
      case EMFILE:
 
343
      case ENFILE:
 
344
      case ETXTBSY:
 
345
      default:
 
346
        _exit(EX_OSERR);
 
347
      case ENOTDIR:
 
348
      case ELOOP:
 
349
      case EISDIR:
 
350
#ifdef ELIBBAD
 
351
      case ELIBBAD:             /* Linux only */
 
352
#endif
 
353
      case EPERM:
 
354
        _exit(EX_OSFILE);
229
355
      }
230
 
      free(prompt);
231
 
      _exit(EXIT_FAILURE);
232
356
    }
 
357
    free(prompt);
 
358
    _exit(EXIT_FAILURE);
233
359
  }
234
360
  
235
361
  /* Parent */
236
362
  free(prompt);
 
363
  prompt = NULL;
 
364
  
 
365
  if(interrupted_by_signal){
 
366
    goto failure;
 
367
  }
237
368
  
238
369
  /* Wait for command to complete */
239
 
  if(not interrupted_by_signal and splashy_command_pid != 0){
 
370
  {
240
371
    int status;
241
 
    ret = waitpid(splashy_command_pid, &status, 0);
 
372
    do {
 
373
      ret = waitpid(splashy_command_pid, &status, 0);
 
374
    } while(ret == -1 and errno == EINTR
 
375
            and not interrupted_by_signal);
 
376
    if(interrupted_by_signal){
 
377
      goto failure;
 
378
    }
242
379
    if(ret == -1){
243
 
      if(errno != EINTR){
244
 
        perror("waitpid");
245
 
      }
 
380
      error_plus(0, errno, "waitpid");
246
381
      if(errno == ECHILD){
247
382
        splashy_command_pid = 0;
248
383
      }
249
384
    } else {
250
385
      /* The child process has exited */
251
386
      splashy_command_pid = 0;
252
 
      if(not interrupted_by_signal and WIFEXITED(status)
253
 
         and WEXITSTATUS(status)==0){
 
387
      if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
254
388
        return EXIT_SUCCESS;
255
389
      }
256
390
    }
257
391
  }
258
 
  kill(splashy_pid, SIGTERM);
259
 
  if(interrupted_by_signal and splashy_command_pid != 0){
260
 
    kill(splashy_command_pid, SIGTERM);
261
 
  }
262
 
  sleep(2);
263
 
  while(kill(splashy_pid, 0) == 0){
264
 
    kill(splashy_pid, SIGKILL);
265
 
    sleep(1);
266
 
  }
267
 
  pid_t new_splashy_pid = fork();
268
 
  if(new_splashy_pid == 0){
269
 
    /* Child; will become new splashy process */
270
 
    
271
 
    /* Make the effective user ID (root) the only user ID instead of
272
 
       the real user ID (_mandos) */
273
 
    ret = setuid(geteuid());
274
 
    if(ret == -1){
275
 
      perror("setuid");
276
 
    }
277
 
    
278
 
    setsid();
279
 
    ret = chdir("/");
280
 
/*     if(fork() != 0){ */
281
 
/*       _exit(EXIT_SUCCESS); */
282
 
/*     } */
283
 
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
284
 
    if(ret == -1){
285
 
      perror("dup2");
286
 
      _exit(EXIT_FAILURE);
287
 
    }
288
 
    
289
 
    execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
290
 
    if(not interrupted_by_signal){
291
 
      perror("execl");
292
 
    }
293
 
    _exit(EXIT_FAILURE);
294
 
  }
295
 
  
296
 
  return EXIT_FAILURE;
 
392
  
 
393
 failure:
 
394
  
 
395
  free(prompt);
 
396
  
 
397
  if(proc_dir != NULL){
 
398
    TEMP_FAILURE_RETRY(closedir(proc_dir));
 
399
  }
 
400
  
 
401
  if(splashy_command_pid != 0){
 
402
    TEMP_FAILURE_RETRY(kill(splashy_command_pid, SIGTERM));
 
403
    
 
404
    TEMP_FAILURE_RETRY(kill(splashy_pid, SIGTERM));
 
405
    sleep(2);
 
406
    while(TEMP_FAILURE_RETRY(kill(splashy_pid, 0)) == 0){
 
407
      TEMP_FAILURE_RETRY(kill(splashy_pid, SIGKILL));
 
408
      sleep(1);
 
409
    }
 
410
    pid_t new_splashy_pid = (pid_t)TEMP_FAILURE_RETRY(fork());
 
411
    if(new_splashy_pid == 0){
 
412
      /* Child; will become new splashy process */
 
413
      
 
414
      /* Make the effective user ID (root) the only user ID instead of
 
415
         the real user ID (_mandos) */
 
416
      ret = setuid(geteuid());
 
417
      if(ret == -1){
 
418
        error_plus(0, errno, "setuid");
 
419
      }
 
420
      
 
421
      setsid();
 
422
      ret = chdir("/");
 
423
      if(ret == -1){
 
424
        error_plus(0, errno, "chdir");
 
425
      }
 
426
/*       if(fork() != 0){ */
 
427
/*      _exit(EXIT_SUCCESS); */
 
428
/*       } */
 
429
      ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
 
430
      if(ret == -1){
 
431
        error_plus(0, errno, "dup2");
 
432
        _exit(EX_OSERR);
 
433
      }
 
434
      
 
435
      execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
 
436
      {
 
437
        int e = errno;
 
438
        error_plus(0, errno, "execl");
 
439
        switch(e){
 
440
        case EACCES:
 
441
        case ENOENT:
 
442
        case ENOEXEC:
 
443
        default:
 
444
          _exit(EX_UNAVAILABLE);
 
445
        case ENAMETOOLONG:
 
446
        case E2BIG:
 
447
        case ENOMEM:
 
448
          _exit(EX_OSERR);
 
449
        case ENOTDIR:
 
450
        case ELOOP:
 
451
          _exit(EX_OSFILE);
 
452
        }
 
453
      }
 
454
    }
 
455
  }
 
456
  
 
457
  if(interrupted_by_signal){
 
458
    struct sigaction signal_action;
 
459
    sigemptyset(&signal_action.sa_mask);
 
460
    signal_action.sa_handler = SIG_DFL;
 
461
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
 
462
                                            &signal_action, NULL));
 
463
    if(ret == -1){
 
464
      error_plus(0, errno, "sigaction");
 
465
    }
 
466
    do {
 
467
      ret = raise(signal_received);
 
468
    } while(ret != 0 and errno == EINTR);
 
469
    if(ret != 0){
 
470
      error_plus(0, errno, "raise");
 
471
      abort();
 
472
    }
 
473
    TEMP_FAILURE_RETRY(pause());
 
474
  }
 
475
  
 
476
  return exitstatus;
297
477
}