/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/password-prompt.c

  • Committer: Teddy Hogeborn
  • Date: 2019-02-09 23:23:26 UTC
  • Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)

Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else.  We choose to use "raw public keys" (RFC 7250).  Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.

Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed).  This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.

* DBUS-API (Signals/ClientNotFound): Change name of first parameter
                                     from "Fingerprint" to "KeyID".
  (Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
           key support) up until 3.6.6, when support for raw public
           keys was added.  Also document new dependency of client on
           "gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
                         as arguments to client.
  (keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
  (confdir/clients.conf): Add dependency on TLS public key.
  (purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
                                                 libgnutls30 (>= 3.6.6)
  (Package: mandos/Depends): - '' -
  (Package: mandos/Description): Alter description to match new
                                 design.
  (Package: mandos-client/Description): - '' -
  (Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
                                    here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
                                      --tls-pubkey options to test
                                      command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
                                             (all callers changed),
                                             and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
                   support for raw public keys is detected.
  (Client.key_id): New attribute.
  (ClientDBus.KeyID_dbus_property): New method.
  (ProxyClient.__init__): Take new "key_id" parameter.
  (ClientHandler.handle): Use key IDs when using raw public keys and
                          use fingerprints when using OpenPGP keys.
  (ClientHandler.peer_certificate): Also handle raw public keys.
  (ClientHandler.key_id): New.
  (MandosServer.handle_ipc): Pass key ID over the pipe IPC.  Also
                             check for key ID matches when looking up
                             clients.
  (main): Default GnuTLS priority string depends on whether we are
          using raw public keys or not.  When unpickling clients, set
          key_id if not set in the pickle.
  (main/MandosDBusService.ClientNotFound): Change name of first
                                           parameter from
                                           "Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
  (OPTIONS/secret): Mention new key ID matchning.
  (EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
  (EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files.  New "--tls-keytype" (-T)
                 option.  Alter help text to be more clear about key
                 types.  When in password mode, also output "key_id"
                 option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
  (DESCRIPTION): Alter to match new dual-key design.
  (OVERVIEW): - '' -
  (FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
                                 when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
  (BUGS): Remove issue about checking expire times of OpenPGP keys,
          since TLS public keys do not have expiration times.
  (SECURITY/CLIENT): Alter description to match new design.
  (SEE ALSO/GnuTLS): - '' -
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
                               options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
                             supporting GnuTLS versions. Add new
                             "--tls-pubkey" and "--tls-privkey"
                             options (which do nothing if GnuTLS
                             library does not support raw public
                             keys).  Alter text throughout to reflect
                             new design.  Only generate new DH
                             parameters (based on size of OpenPGP key)
                             when using OpenPGP in TLS.  Default
                             GnuTLS priority string depends on whether
                             we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
                                          and "--tls-pubkey" (-T)
                                          options.
  (DESCRIPTION): Describe new dual-key design.
  (OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
             options.
  (OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
                       size.
  (FILES): Add default locations for TLS public and private key files.
  (EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
  (SECURITY): Alter wording slightly to reflect new dual-key design.
  (SEE ALSO/GnuTLS): Alter description to match new design.
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/password-prompt.c
2
2
/*
3
3
 * Password-prompt - Read a password from the terminal and print it
4
4
 * 
5
 
 * Copyright © 2008-2010 Teddy Hogeborn
6
 
 * Copyright © 2008-2010 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 <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
26
#define _GNU_SOURCE             /* getline(), asprintf() */
26
27
 
27
 
#include <termios.h>            /* struct termios, tcsetattr(),
 
28
#include <termios.h>            /* struct termios, tcsetattr(),
28
29
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
30
#include <unistd.h>             /* struct termios, tcsetattr(),
30
31
                                   STDIN_FILENO, TCSAFLUSH,
35
36
                                   SIGQUIT, SIGHUP, SIGTERM,
36
37
                                   raise() */
37
38
#include <stddef.h>             /* NULL, size_t, ssize_t */
38
 
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t, ssize_t */
 
39
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
40
                                   ssize_t, open() */
39
41
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
42
                                   getenv(), free() */
41
43
#include <dirent.h>             /* scandir(), alphasort() */
42
44
#include <stdio.h>              /* fprintf(), stderr, getline(),
43
 
                                   stdin, feof(), fputc()
44
 
                                */
 
45
                                   stdin, feof(), fputc(), vfprintf(),
 
46
                                   vasprintf() */
45
47
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
46
48
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
47
49
                                */
49
51
#include <iso646.h>             /* or, not */
50
52
#include <stdbool.h>            /* bool, false, true */
51
53
#include <inttypes.h>           /* strtoumax() */
52
 
#include <sys/stat.h>           /* struct stat, lstat() */
53
 
#include <string.h>             /* strlen, rindex, memcmp */
 
54
#include <sys/stat.h>           /* struct stat, lstat(), open() */
 
55
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
56
                                 */
54
57
#include <argp.h>               /* struct argp_option, struct
55
58
                                   argp_state, struct argp,
56
59
                                   argp_parse(), error_t,
58
61
                                   ARGP_ERR_UNKNOWN */
59
62
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
60
63
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
64
#include <fcntl.h>              /* open() */
 
65
#include <stdarg.h>             /* va_list, va_start(), ... */
61
66
 
62
67
volatile sig_atomic_t quit_now = 0;
63
68
int signal_received;
64
69
bool debug = false;
65
70
const char *argp_program_version = "password-prompt " VERSION;
66
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
67
 
 
68
 
/* Needed for conflic resolution */
69
 
const char plymouthd_path[] = "/sbin/plymouth";
70
 
 
 
71
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
72
 
 
73
/* Needed for conflict resolution */
 
74
const char plymouth_name[] = "plymouthd";
 
75
 
 
76
/* Function to use when printing errors */
 
77
__attribute__((format (gnu_printf, 3, 4)))
 
78
void error_plus(int status, int errnum, const char *formatstring,
 
79
                ...){
 
80
  va_list ap;
 
81
  char *text;
 
82
  int ret;
 
83
  
 
84
  va_start(ap, formatstring);
 
85
  ret = vasprintf(&text, formatstring, ap);
 
86
  if(ret == -1){
 
87
    fprintf(stderr, "Mandos plugin %s: ",
 
88
            program_invocation_short_name);
 
89
    vfprintf(stderr, formatstring, ap);
 
90
    fprintf(stderr, ": %s\n", strerror(errnum));
 
91
    error(status, errno, "vasprintf while printing error");
 
92
    return;
 
93
  }
 
94
  fprintf(stderr, "Mandos plugin ");
 
95
  error(status, errnum, "%s", text);
 
96
  free(text);
 
97
}
71
98
 
72
99
static void termination_handler(int signum){
73
100
  if(quit_now){
79
106
 
80
107
bool conflict_detection(void){
81
108
 
82
 
  /* plymouth conflicts with password-promt since both want to control the
83
 
     associated terminal. Password-prompt exit since plymouth perferms the same
84
 
     functionallity.
 
109
  /* plymouth conflicts with password-prompt since both want to read
 
110
     from the terminal.  Password-prompt will exit if it detects
 
111
     plymouth since plymouth performs the same functionality.
85
112
   */
 
113
  __attribute__((nonnull))
86
114
  int is_plymouth(const struct dirent *proc_entry){
87
115
    int ret;
 
116
    int cl_fd;
88
117
    {
89
 
      uintmax_t maxvalue;
 
118
      uintmax_t proc_id;
90
119
      char *tmp;
91
120
      errno = 0;
92
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
121
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
93
122
      
94
123
      if(errno != 0 or *tmp != '\0'
95
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
124
         or proc_id != (uintmax_t)((pid_t)proc_id)){
96
125
        return 0;
97
126
      }
98
127
    }
99
 
    char exe_target[sizeof(plymouthd_path)];
100
 
    char *exe_link;
101
 
    ret = asprintf(&exe_link, "/proc/%s/exe", proc_entry->d_name);
 
128
    
 
129
    char *cmdline_filename;
 
130
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
131
                   proc_entry->d_name);
102
132
    if(ret == -1){
103
 
      error(0, errno, "asprintf");
 
133
      error_plus(0, errno, "asprintf");
104
134
      return 0;
105
135
    }
106
 
  
107
 
    struct stat exe_stat;
108
 
    ret = lstat(exe_link, &exe_stat);
109
 
    if(ret == -1){
110
 
      free(exe_link);
 
136
    
 
137
    /* Open /proc/<pid>/cmdline */
 
138
    cl_fd = open(cmdline_filename, O_RDONLY);
 
139
    free(cmdline_filename);
 
140
    if(cl_fd == -1){
111
141
      if(errno != ENOENT){
112
 
        error(0, errno, "lstat");
113
 
      }
114
 
      return 0;
115
 
    }
116
 
  
117
 
    if(not S_ISLNK(exe_stat.st_mode)
118
 
       or exe_stat.st_uid != 0
119
 
       or exe_stat.st_gid != 0){
120
 
      free(exe_link);
121
 
      return 0;
122
 
    }
123
 
  
124
 
    ssize_t sret = readlink(exe_link, exe_target, sizeof(exe_target));
125
 
    free(exe_link);
126
 
    if((sret != (ssize_t)sizeof(plymouthd_path)-1) or
127
 
       (memcmp(plymouthd_path, exe_target,
128
 
               sizeof(plymouthd_path)-1) != 0)){
129
 
      return 0;
130
 
    }
 
142
        error_plus(0, errno, "open");
 
143
      }
 
144
      return 0;
 
145
    }
 
146
    
 
147
    char *cmdline = NULL;
 
148
    {
 
149
      size_t cmdline_len = 0;
 
150
      size_t cmdline_allocated = 0;
 
151
      char *tmp;
 
152
      const size_t blocksize = 1024;
 
153
      ssize_t sret;
 
154
      do {
 
155
        /* Allocate more space? */
 
156
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
 
157
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
 
158
          if(tmp == NULL){
 
159
            error_plus(0, errno, "realloc");
 
160
            free(cmdline);
 
161
            close(cl_fd);
 
162
            return 0;
 
163
          }
 
164
          cmdline = tmp;
 
165
          cmdline_allocated += blocksize;
 
166
        }
 
167
        
 
168
        /* Read data */
 
169
        sret = read(cl_fd, cmdline + cmdline_len,
 
170
                    cmdline_allocated - cmdline_len);
 
171
        if(sret == -1){
 
172
          error_plus(0, errno, "read");
 
173
          free(cmdline);
 
174
          close(cl_fd);
 
175
          return 0;
 
176
        }
 
177
        cmdline_len += (size_t)sret;
 
178
      } while(sret != 0);
 
179
      ret = close(cl_fd);
 
180
      if(ret == -1){
 
181
        error_plus(0, errno, "close");
 
182
        free(cmdline);
 
183
        return 0;
 
184
      }
 
185
      cmdline[cmdline_len] = '\0'; /* Make sure it is terminated */
 
186
    }
 
187
    /* we now have cmdline */
 
188
    
 
189
    /* get basename */
 
190
    char *cmdline_base = strrchr(cmdline, '/');
 
191
    if(cmdline_base != NULL){
 
192
      cmdline_base += 1;                /* skip the slash */
 
193
    } else {
 
194
      cmdline_base = cmdline;
 
195
    }
 
196
    
 
197
    if(strcmp(cmdline_base, plymouth_name) != 0){
 
198
      if(debug){
 
199
        fprintf(stderr, "\"%s\" is not \"%s\"\n", cmdline_base,
 
200
                plymouth_name);
 
201
      }
 
202
      free(cmdline);
 
203
      return 0;
 
204
    }
 
205
    if(debug){
 
206
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
207
              plymouth_name);
 
208
    }
 
209
    free(cmdline);
131
210
    return 1;
132
211
  }
133
 
 
134
 
  struct dirent **direntries;
 
212
  
 
213
  struct dirent **direntries = NULL;
135
214
  int ret;
136
215
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
137
 
  if (ret == -1){
138
 
    error(1, errno, "scandir");
139
 
  }
140
 
  if (ret < 0){
141
 
    return 1;
142
 
  } else {
143
 
    return 0;
144
 
  }
 
216
  if(ret == -1){
 
217
    error_plus(1, errno, "scandir");
 
218
  }
 
219
  {
 
220
    int i = ret;
 
221
    while(i--){
 
222
      free(direntries[i]);
 
223
    }
 
224
  }
 
225
  free(direntries);
 
226
  return ret > 0;
145
227
}
146
228
 
147
229
 
175
257
      { .name = NULL }
176
258
    };
177
259
    
 
260
    __attribute__((nonnull(3)))
178
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
179
262
      errno = 0;
180
263
      switch (key){
216
299
    case ENOMEM:
217
300
    default:
218
301
      errno = ret;
219
 
      error(0, errno, "argp_parse");
 
302
      error_plus(0, errno, "argp_parse");
220
303
      return EX_OSERR;
221
304
    case EINVAL:
222
305
      return EX_USAGE;
227
310
    fprintf(stderr, "Starting %s\n", argv[0]);
228
311
  }
229
312
 
230
 
  if (conflict_detection()){
 
313
  if(conflict_detection()){
231
314
    if(debug){
232
 
      fprintf(stderr, "Stopping %s because of conflict", argv[0]);
 
315
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
233
316
    }
234
317
    return EXIT_FAILURE;
235
318
  }
240
323
  
241
324
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
242
325
    int e = errno;
243
 
    error(0, errno, "tcgetattr");
 
326
    error_plus(0, errno, "tcgetattr");
244
327
    switch(e){
245
328
    case EBADF:
246
329
    case ENOTTY:
253
336
  sigemptyset(&new_action.sa_mask);
254
337
  ret = sigaddset(&new_action.sa_mask, SIGINT);
255
338
  if(ret == -1){
256
 
    error(0, errno, "sigaddset");
 
339
    error_plus(0, errno, "sigaddset");
257
340
    return EX_OSERR;
258
341
  }
259
342
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
260
343
  if(ret == -1){
261
 
    error(0, errno, "sigaddset");
 
344
    error_plus(0, errno, "sigaddset");
262
345
    return EX_OSERR;
263
346
  }
264
347
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
265
348
  if(ret == -1){
266
 
    error(0, errno, "sigaddset");
 
349
    error_plus(0, errno, "sigaddset");
267
350
    return EX_OSERR;
268
351
  }
269
352
  /* Need to check if the handler is SIG_IGN before handling:
272
355
  */
273
356
  ret = sigaction(SIGINT, NULL, &old_action);
274
357
  if(ret == -1){
275
 
    error(0, errno, "sigaction");
 
358
    error_plus(0, errno, "sigaction");
276
359
    return EX_OSERR;
277
360
  }
278
361
  if(old_action.sa_handler != SIG_IGN){
279
362
    ret = sigaction(SIGINT, &new_action, NULL);
280
363
    if(ret == -1){
281
 
      error(0, errno, "sigaction");
 
364
      error_plus(0, errno, "sigaction");
282
365
      return EX_OSERR;
283
366
    }
284
367
  }
285
368
  ret = sigaction(SIGHUP, NULL, &old_action);
286
369
  if(ret == -1){
287
 
    error(0, errno, "sigaction");
 
370
    error_plus(0, errno, "sigaction");
288
371
    return EX_OSERR;
289
372
  }
290
373
  if(old_action.sa_handler != SIG_IGN){
291
374
    ret = sigaction(SIGHUP, &new_action, NULL);
292
375
    if(ret == -1){
293
 
      error(0, errno, "sigaction");
 
376
      error_plus(0, errno, "sigaction");
294
377
      return EX_OSERR;
295
378
    }
296
379
  }
297
380
  ret = sigaction(SIGTERM, NULL, &old_action);
298
381
  if(ret == -1){
299
 
    error(0, errno, "sigaction");
 
382
    error_plus(0, errno, "sigaction");
300
383
    return EX_OSERR;
301
384
  }
302
385
  if(old_action.sa_handler != SIG_IGN){
303
386
    ret = sigaction(SIGTERM, &new_action, NULL);
304
387
    if(ret == -1){
305
 
      error(0, errno, "sigaction");
 
388
      error_plus(0, errno, "sigaction");
306
389
      return EX_OSERR;
307
390
    }
308
391
  }
316
399
  t_new.c_lflag &= ~(tcflag_t)ECHO;
317
400
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
318
401
    int e = errno;
319
 
    error(0, errno, "tcsetattr-echo");
 
402
    error_plus(0, errno, "tcsetattr-echo");
320
403
    switch(e){
321
404
    case EBADF:
322
405
    case ENOTTY:
386
469
        sret = write(STDOUT_FILENO, buffer + written, n - written);
387
470
        if(sret < 0){
388
471
          int e = errno;
389
 
          error(0, errno, "write");
 
472
          error_plus(0, errno, "write");
390
473
          switch(e){
391
474
          case EBADF:
392
475
          case EFAULT:
408
491
      sret = close(STDOUT_FILENO);
409
492
      if(sret == -1){
410
493
        int e = errno;
411
 
        error(0, errno, "close");
 
494
        error_plus(0, errno, "close");
412
495
        switch(e){
413
496
        case EBADF:
414
497
          status = EX_OSFILE;
424
507
    if(sret < 0){
425
508
      int e = errno;
426
509
      if(errno != EINTR and not feof(stdin)){
427
 
        error(0, errno, "getline");
 
510
        error_plus(0, errno, "getline");
428
511
        switch(e){
429
512
        case EBADF:
430
513
          status = EX_UNAVAILABLE;
 
514
          break;
431
515
        case EIO:
432
516
        case EINVAL:
433
517
        default:
437
521
        break;
438
522
      }
439
523
    }
440
 
    /* if(sret == 0), then the only sensible thing to do is to retry to
441
 
       read from stdin */
 
524
    /* if(sret == 0), then the only sensible thing to do is to retry
 
525
       to read from stdin */
442
526
    fputc('\n', stderr);
443
527
    if(debug and not quit_now){
444
528
      /* If quit_now is nonzero, we were interrupted by a signal, and
453
537
    fprintf(stderr, "Restoring terminal attributes\n");
454
538
  }
455
539
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
456
 
    error(0, errno, "tcsetattr+echo");
 
540
    error_plus(0, errno, "tcsetattr+echo");
457
541
  }
458
542
  
459
543
  if(quit_now){
461
545
    old_action.sa_handler = SIG_DFL;
462
546
    ret = sigaction(signal_received, &old_action, NULL);
463
547
    if(ret == -1){
464
 
      error(0, errno, "sigaction");
 
548
      error_plus(0, errno, "sigaction");
465
549
    }
466
550
    raise(signal_received);
467
551
  }