/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/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2015-05-23 20:18:34 UTC
  • mto: This revision was merged to the branch mainline in revision 756.
  • Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.

For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished".  This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found.  One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD.  To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous).  In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.

This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.

DBUS-API (CheckerCompleted): Change the second value provided by this
                             D-Bus signal from the raw wait(2) status
                             to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
                               multiprocessing.Process (starting a
                               separate process).
(Client.last_checker signal): New attribute for signal which
                              terminated last checker.  Like
                              last_checker_status, only not accessible
                              via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
                           to get returncode; set last_checker_signal.
                           Return False so gobject does not call this
                           callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
                        instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument.        Call
                               Client.checker_callback early to have
                               it set last_checker_status and
                               last_checker_signal; use those.  Change
                               second value provided to D-Bus signal
                               CheckerCompleted to use
                               last_checker_signal if checker was
                               terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
                                        "condition" argument.  Use it
                                        accordingly.  Remove dead code
                                        (os.WCOREDUMP case).

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2019 Teddy Hogeborn
13
 
 * Copyright © 2008-2019 Björn Påhlsson
14
 
 * 
15
 
 * This file is part of Mandos.
16
 
 * 
17
 
 * Mandos is free software: you can redistribute it and/or modify it
18
 
 * under the terms of the GNU General Public License as published by
19
 
 * the Free Software Foundation, either version 3 of the License, or
20
 
 * (at your option) any later version.
21
 
 * 
22
 
 * Mandos is distributed in the hope that it will be useful, but
 
12
 * Copyright © 2008-2014 Teddy Hogeborn
 
13
 * Copyright © 2008-2014 Björn Påhlsson
 
14
 * 
 
15
 * This program is free software: you can redistribute it and/or
 
16
 * modify it under the terms of the GNU General Public License as
 
17
 * published by the Free Software Foundation, either version 3 of the
 
18
 * License, or (at your option) any later version.
 
19
 * 
 
20
 * This program is distributed in the hope that it will be useful, but
23
21
 * WITHOUT ANY WARRANTY; without even the implied warranty of
24
22
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
23
 * General Public License for more details.
26
24
 * 
27
25
 * You should have received a copy of the GNU General Public License
28
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
26
 * along with this program.  If not, see
 
27
 * <http://www.gnu.org/licenses/>.
29
28
 * 
30
29
 * Contact the authors at <mandos@recompile.se>.
31
30
 */
47
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
48
47
                                   strtof(), abort() */
49
48
#include <stdbool.h>            /* bool, false, true */
50
 
#include <string.h>             /* strcmp(), strlen(), strerror(),
51
 
                                   asprintf(), strncpy(), strsignal()
52
 
                                */
 
49
#include <string.h>             /* memset(), strcmp(), strlen(),
 
50
                                   strerror(), asprintf(), strcpy() */
53
51
#include <sys/ioctl.h>          /* ioctl */
54
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
55
53
                                   sockaddr_in6, PF_INET6,
59
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
60
58
                                   inet_pton(), connect(),
61
59
                                   getnameinfo() */
62
 
#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
63
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
64
62
                                 */
65
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
66
64
                                   strtoimax() */
67
 
#include <errno.h>              /* perror(), errno, EINTR, EINVAL,
68
 
                                   EAI_SYSTEM, ENETUNREACH,
69
 
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
 
                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
 
                                   ENOTEMPTY,
 
65
#include <errno.h>              /* perror(), errno,
72
66
                                   program_invocation_short_name */
73
67
#include <time.h>               /* nanosleep(), time(), sleep() */
74
68
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
123
117
                                   gnutls_*
124
118
                                   init_gnutls_session(),
125
119
                                   GNUTLS_* */
126
 
#if GNUTLS_VERSION_NUMBER < 0x030600
127
120
#include <gnutls/openpgp.h>
128
121
                         /* gnutls_certificate_set_openpgp_key_file(),
129
122
                            GNUTLS_OPENPGP_FMT_BASE64 */
130
 
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
 
#include <gnutls/x509.h>        /* gnutls_pkcs_encrypt_flags_t,
132
 
                                 GNUTLS_PKCS_PLAIN,
133
 
                                 GNUTLS_PKCS_NULL_PASSWORD */
134
 
#endif
135
123
 
136
124
/* GPGME */
137
125
#include <gpgme.h>              /* All GPGME types, constants and
145
133
#define PATHDIR "/conf/conf.d/mandos"
146
134
#define SECKEY "seckey.txt"
147
135
#define PUBKEY "pubkey.txt"
148
 
#define TLS_PRIVKEY "tls-privkey.pem"
149
 
#define TLS_PUBKEY "tls-pubkey.pem"
150
136
#define HOOKDIR "/lib/mandos/network-hooks.d"
151
137
 
152
138
bool debug = false;
280
266
  return true;
281
267
}
282
268
 
283
 
/* Set effective uid to 0, return errno */
284
 
__attribute__((warn_unused_result))
285
 
int raise_privileges(void){
286
 
  int old_errno = errno;
287
 
  int ret = 0;
288
 
  if(seteuid(0) == -1){
289
 
    ret = errno;
290
 
  }
291
 
  errno = old_errno;
292
 
  return ret;
293
 
}
294
 
 
295
 
/* Set effective and real user ID to 0.  Return errno. */
296
 
__attribute__((warn_unused_result))
297
 
int raise_privileges_permanently(void){
298
 
  int old_errno = errno;
299
 
  int ret = raise_privileges();
300
 
  if(ret != 0){
301
 
    errno = old_errno;
302
 
    return ret;
303
 
  }
304
 
  if(setuid(0) == -1){
305
 
    ret = errno;
306
 
  }
307
 
  errno = old_errno;
308
 
  return ret;
309
 
}
310
 
 
311
 
/* Set effective user ID to unprivileged saved user ID */
312
 
__attribute__((warn_unused_result))
313
 
int lower_privileges(void){
314
 
  int old_errno = errno;
315
 
  int ret = 0;
316
 
  if(seteuid(uid) == -1){
317
 
    ret = errno;
318
 
  }
319
 
  errno = old_errno;
320
 
  return ret;
321
 
}
322
 
 
323
 
/* Lower privileges permanently */
324
 
__attribute__((warn_unused_result))
325
 
int lower_privileges_permanently(void){
326
 
  int old_errno = errno;
327
 
  int ret = 0;
328
 
  if(setuid(uid) == -1){
329
 
    ret = errno;
330
 
  }
331
 
  errno = old_errno;
332
 
  return ret;
333
 
}
334
 
 
335
269
/* 
336
270
 * Initialize GPGME.
337
271
 */
357
291
      return false;
358
292
    }
359
293
    
360
 
    /* Workaround for systems without a real-time clock; see also
361
 
       Debian bug #894495: <https://bugs.debian.org/894495> */
362
 
    do {
363
 
      {
364
 
        time_t currtime = time(NULL);
365
 
        if(currtime != (time_t)-1){
366
 
          struct tm tm;
367
 
          if(gmtime_r(&currtime, &tm) == NULL) {
368
 
            perror_plus("gmtime_r");
369
 
            break;
370
 
          }
371
 
          if(tm.tm_year != 70 or tm.tm_mon != 0){
372
 
            break;
373
 
          }
374
 
          if(debug){
375
 
            fprintf_plus(stderr, "System clock is January 1970");
376
 
          }
377
 
        } else {
378
 
          if(debug){
379
 
            fprintf_plus(stderr, "System clock is invalid");
380
 
          }
381
 
        }
382
 
      }
383
 
      struct stat keystat;
384
 
      ret = fstat(fd, &keystat);
385
 
      if(ret != 0){
386
 
        perror_plus("fstat");
387
 
        break;
388
 
      }
389
 
      ret = raise_privileges();
390
 
      if(ret != 0){
391
 
        errno = ret;
392
 
        perror_plus("Failed to raise privileges");
393
 
        break;
394
 
      }
395
 
      if(debug){
396
 
        fprintf_plus(stderr,
397
 
                     "Setting system clock to key file mtime");
398
 
      }
399
 
      time_t keytime = keystat.st_mtim.tv_sec;
400
 
      if(stime(&keytime) != 0){
401
 
        perror_plus("stime");
402
 
      }
403
 
      ret = lower_privileges();
404
 
      if(ret != 0){
405
 
        errno = ret;
406
 
        perror_plus("Failed to lower privileges");
407
 
      }
408
 
    } while(false);
409
 
 
410
294
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
411
295
    if(rc != GPG_ERR_NO_ERROR){
412
296
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
420
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
421
305
      return false;
422
306
    }
423
 
    {
424
 
      gpgme_import_result_t import_result
425
 
        = gpgme_op_import_result(mc->ctx);
426
 
      if((import_result->imported < 1
427
 
          or import_result->not_imported > 0)
428
 
         and import_result->unchanged == 0){
429
 
        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
430
 
        fprintf_plus(stderr,
431
 
                     "The total number of considered keys: %d\n",
432
 
                     import_result->considered);
433
 
        fprintf_plus(stderr,
434
 
                     "The number of keys without user ID: %d\n",
435
 
                     import_result->no_user_id);
436
 
        fprintf_plus(stderr,
437
 
                     "The total number of imported keys: %d\n",
438
 
                     import_result->imported);
439
 
        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
440
 
                     import_result->imported_rsa);
441
 
        fprintf_plus(stderr, "The number of unchanged keys: %d\n",
442
 
                     import_result->unchanged);
443
 
        fprintf_plus(stderr, "The number of new user IDs: %d\n",
444
 
                     import_result->new_user_ids);
445
 
        fprintf_plus(stderr, "The number of new sub keys: %d\n",
446
 
                     import_result->new_sub_keys);
447
 
        fprintf_plus(stderr, "The number of new signatures: %d\n",
448
 
                     import_result->new_signatures);
449
 
        fprintf_plus(stderr, "The number of new revocations: %d\n",
450
 
                     import_result->new_revocations);
451
 
        fprintf_plus(stderr,
452
 
                     "The total number of secret keys read: %d\n",
453
 
                     import_result->secret_read);
454
 
        fprintf_plus(stderr,
455
 
                     "The number of imported secret keys: %d\n",
456
 
                     import_result->secret_imported);
457
 
        fprintf_plus(stderr,
458
 
                     "The number of unchanged secret keys: %d\n",
459
 
                     import_result->secret_unchanged);
460
 
        fprintf_plus(stderr, "The number of keys not imported: %d\n",
461
 
                     import_result->not_imported);
462
 
        for(gpgme_import_status_t import_status
463
 
              = import_result->imports;
464
 
            import_status != NULL;
465
 
            import_status = import_status->next){
466
 
          fprintf_plus(stderr, "Import status for key: %s\n",
467
 
                       import_status->fpr);
468
 
          if(import_status->result != GPG_ERR_NO_ERROR){
469
 
            fprintf_plus(stderr, "Import result: %s: %s\n",
470
 
                         gpgme_strsource(import_status->result),
471
 
                         gpgme_strerror(import_status->result));
472
 
          }
473
 
          fprintf_plus(stderr, "Key status:\n");
474
 
          fprintf_plus(stderr,
475
 
                       import_status->status & GPGME_IMPORT_NEW
476
 
                       ? "The key was new.\n"
477
 
                       : "The key was not new.\n");
478
 
          fprintf_plus(stderr,
479
 
                       import_status->status & GPGME_IMPORT_UID
480
 
                       ? "The key contained new user IDs.\n"
481
 
                       : "The key did not contain new user IDs.\n");
482
 
          fprintf_plus(stderr,
483
 
                       import_status->status & GPGME_IMPORT_SIG
484
 
                       ? "The key contained new signatures.\n"
485
 
                       : "The key did not contain new signatures.\n");
486
 
          fprintf_plus(stderr,
487
 
                       import_status->status & GPGME_IMPORT_SUBKEY
488
 
                       ? "The key contained new sub keys.\n"
489
 
                       : "The key did not contain new sub keys.\n");
490
 
          fprintf_plus(stderr,
491
 
                       import_status->status & GPGME_IMPORT_SECRET
492
 
                       ? "The key contained a secret key.\n"
493
 
                       : "The key did not contain a secret key.\n");
494
 
        }
495
 
        return false;
496
 
      }
497
 
    }
498
307
    
499
 
    ret = close(fd);
 
308
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
500
309
    if(ret == -1){
501
310
      perror_plus("close");
502
311
    }
541
350
  /* Create new GPGME "context" */
542
351
  rc = gpgme_new(&(mc->ctx));
543
352
  if(rc != GPG_ERR_NO_ERROR){
544
 
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
 
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
353
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
354
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
 
355
                 gpgme_strerror(rc));
546
356
    return false;
547
357
  }
548
358
  
584
394
  /* Create new empty GPGME data buffer for the plaintext */
585
395
  rc = gpgme_data_new(&dh_plain);
586
396
  if(rc != GPG_ERR_NO_ERROR){
587
 
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
 
397
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
398
                 "bad gpgme_data_new: %s: %s\n",
588
399
                 gpgme_strsource(rc), gpgme_strerror(rc));
589
400
    gpgme_data_release(dh_crypto);
590
401
    return -1;
603
414
      if(result == NULL){
604
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
605
416
      } else {
606
 
        if(result->unsupported_algorithm != NULL) {
607
 
          fprintf_plus(stderr, "Unsupported algorithm: %s\n",
608
 
                       result->unsupported_algorithm);
609
 
        }
610
 
        fprintf_plus(stderr, "Wrong key usage: %s\n",
611
 
                     result->wrong_key_usage ? "Yes" : "No");
 
417
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
418
                     result->unsupported_algorithm);
 
419
        fprintf_plus(stderr, "Wrong key usage: %u\n",
 
420
                     result->wrong_key_usage);
612
421
        if(result->file_name != NULL){
613
422
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
614
423
        }
615
 
 
616
 
        for(gpgme_recipient_t r = result->recipients; r != NULL;
617
 
            r = r->next){
 
424
        gpgme_recipient_t recipient;
 
425
        recipient = result->recipients;
 
426
        while(recipient != NULL){
618
427
          fprintf_plus(stderr, "Public key algorithm: %s\n",
619
 
                       gpgme_pubkey_algo_name(r->pubkey_algo));
620
 
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
 
428
                       gpgme_pubkey_algo_name
 
429
                       (recipient->pubkey_algo));
 
430
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
621
431
          fprintf_plus(stderr, "Secret key available: %s\n",
622
 
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
 
432
                       recipient->status == GPG_ERR_NO_SECKEY
 
433
                       ? "No" : "Yes");
 
434
          recipient = recipient->next;
623
435
        }
624
436
      }
625
437
    }
701
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
702
514
}
703
515
 
704
 
__attribute__((nonnull(1, 2, 4), warn_unused_result))
 
516
__attribute__((nonnull, warn_unused_result))
705
517
static int init_gnutls_global(const char *pubkeyfilename,
706
518
                              const char *seckeyfilename,
707
 
                              const char *dhparamsfilename,
708
519
                              mandos_context *mc){
709
520
  int ret;
 
521
  unsigned int uret;
710
522
  
711
523
  if(debug){
712
524
    fprintf_plus(stderr, "Initializing GnuTLS\n");
713
525
  }
714
526
  
 
527
  ret = gnutls_global_init();
 
528
  if(ret != GNUTLS_E_SUCCESS){
 
529
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
530
                 safer_gnutls_strerror(ret));
 
531
    return -1;
 
532
  }
 
533
  
715
534
  if(debug){
716
535
    /* "Use a log level over 10 to enable all debugging options."
717
536
     * - GnuTLS manual
725
544
  if(ret != GNUTLS_E_SUCCESS){
726
545
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
727
546
                 safer_gnutls_strerror(ret));
 
547
    gnutls_global_deinit();
728
548
    return -1;
729
549
  }
730
550
  
731
551
  if(debug){
732
 
    fprintf_plus(stderr, "Attempting to use public key %s and"
733
 
                 " private key %s as GnuTLS credentials\n",
 
552
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
553
                 " secret key %s as GnuTLS credentials\n",
734
554
                 pubkeyfilename,
735
555
                 seckeyfilename);
736
556
  }
737
557
  
738
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
739
 
  ret = gnutls_certificate_set_rawpk_key_file
740
 
    (mc->cred, pubkeyfilename, seckeyfilename,
741
 
     GNUTLS_X509_FMT_PEM,       /* format */
742
 
     NULL,                      /* pass */
743
 
     /* key_usage */
744
 
     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
745
 
     NULL,                      /* names */
746
 
     0,                         /* names_length */
747
 
     /* privkey_flags */
748
 
     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
749
 
     0);                        /* pkcs11_flags */
750
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
751
558
  ret = gnutls_certificate_set_openpgp_key_file
752
559
    (mc->cred, pubkeyfilename, seckeyfilename,
753
560
     GNUTLS_OPENPGP_FMT_BASE64);
754
 
#else
755
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
 
#endif
757
561
  if(ret != GNUTLS_E_SUCCESS){
758
562
    fprintf_plus(stderr,
759
 
                 "Error[%d] while reading the key pair ('%s',"
 
563
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
760
564
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
761
565
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
762
566
                 safer_gnutls_strerror(ret));
771
575
                 safer_gnutls_strerror(ret));
772
576
    goto globalfail;
773
577
  }
774
 
  /* If a Diffie-Hellman parameters file was given, try to use it */
775
 
  if(dhparamsfilename != NULL){
776
 
    gnutls_datum_t params = { .data = NULL, .size = 0 };
777
 
    do {
778
 
      int dhpfile = open(dhparamsfilename, O_RDONLY);
779
 
      if(dhpfile == -1){
780
 
        perror_plus("open");
781
 
        dhparamsfilename = NULL;
782
 
        break;
783
 
      }
784
 
      size_t params_capacity = 0;
 
578
  if(mc->dh_bits == 0){
 
579
    /* Find out the optimal number of DH bits */
 
580
    /* Try to read the private key file */
 
581
    gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
582
    {
 
583
      int secfile = open(seckeyfilename, O_RDONLY);
 
584
      size_t buffer_capacity = 0;
785
585
      while(true){
786
 
        params_capacity = incbuffer((char **)&params.data,
787
 
                                    (size_t)params.size,
788
 
                                    (size_t)params_capacity);
789
 
        if(params_capacity == 0){
 
586
        buffer_capacity = incbuffer((char **)&buffer.data,
 
587
                                    (size_t)buffer.size,
 
588
                                    (size_t)buffer_capacity);
 
589
        if(buffer_capacity == 0){
790
590
          perror_plus("incbuffer");
791
 
          free(params.data);
792
 
          params.data = NULL;
793
 
          dhparamsfilename = NULL;
 
591
          free(buffer.data);
 
592
          buffer.data = NULL;
794
593
          break;
795
594
        }
796
 
        ssize_t bytes_read = read(dhpfile,
797
 
                                  params.data + params.size,
 
595
        ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
798
596
                                  BUFFER_SIZE);
799
597
        /* EOF */
800
598
        if(bytes_read == 0){
803
601
        /* check bytes_read for failure */
804
602
        if(bytes_read < 0){
805
603
          perror_plus("read");
806
 
          free(params.data);
807
 
          params.data = NULL;
808
 
          dhparamsfilename = NULL;
809
 
          break;
810
 
        }
811
 
        params.size += (unsigned int)bytes_read;
812
 
      }
813
 
      ret = close(dhpfile);
814
 
      if(ret == -1){
815
 
        perror_plus("close");
816
 
      }
817
 
      if(params.data == NULL){
818
 
        dhparamsfilename = NULL;
819
 
      }
820
 
      if(dhparamsfilename == NULL){
821
 
        break;
822
 
      }
823
 
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
824
 
                                          GNUTLS_X509_FMT_PEM);
825
 
      if(ret != GNUTLS_E_SUCCESS){
826
 
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
827
 
                     " \"%s\": %s\n", dhparamsfilename,
828
 
                     safer_gnutls_strerror(ret));
829
 
        dhparamsfilename = NULL;
830
 
      }
831
 
      free(params.data);
832
 
    } while(false);
833
 
  }
834
 
  if(dhparamsfilename == NULL){
835
 
    if(mc->dh_bits == 0){
836
 
#if GNUTLS_VERSION_NUMBER < 0x030600
837
 
      /* Find out the optimal number of DH bits */
838
 
      /* Try to read the private key file */
839
 
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
840
 
      do {
841
 
        int secfile = open(seckeyfilename, O_RDONLY);
842
 
        if(secfile == -1){
843
 
          perror_plus("open");
844
 
          break;
845
 
        }
846
 
        size_t buffer_capacity = 0;
847
 
        while(true){
848
 
          buffer_capacity = incbuffer((char **)&buffer.data,
849
 
                                      (size_t)buffer.size,
850
 
                                      (size_t)buffer_capacity);
851
 
          if(buffer_capacity == 0){
852
 
            perror_plus("incbuffer");
853
 
            free(buffer.data);
854
 
            buffer.data = NULL;
855
 
            break;
856
 
          }
857
 
          ssize_t bytes_read = read(secfile,
858
 
                                    buffer.data + buffer.size,
859
 
                                    BUFFER_SIZE);
860
 
          /* EOF */
861
 
          if(bytes_read == 0){
862
 
            break;
863
 
          }
864
 
          /* check bytes_read for failure */
865
 
          if(bytes_read < 0){
866
 
            perror_plus("read");
867
 
            free(buffer.data);
868
 
            buffer.data = NULL;
869
 
            break;
870
 
          }
871
 
          buffer.size += (unsigned int)bytes_read;
872
 
        }
873
 
        close(secfile);
874
 
      } while(false);
875
 
      /* If successful, use buffer to parse private key */
876
 
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
877
 
      if(buffer.data != NULL){
878
 
        {
879
 
          gnutls_openpgp_privkey_t privkey = NULL;
880
 
          ret = gnutls_openpgp_privkey_init(&privkey);
 
604
          free(buffer.data);
 
605
          buffer.data = NULL;
 
606
          break;
 
607
        }
 
608
        buffer.size += (unsigned int)bytes_read;
 
609
      }
 
610
      close(secfile);
 
611
    }
 
612
    /* If successful, use buffer to parse private key */
 
613
    gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
614
    if(buffer.data != NULL){
 
615
      {
 
616
        gnutls_openpgp_privkey_t privkey = NULL;
 
617
        ret = gnutls_openpgp_privkey_init(&privkey);
 
618
        if(ret != GNUTLS_E_SUCCESS){
 
619
          fprintf_plus(stderr, "Error initializing OpenPGP key"
 
620
                       " structure: %s", safer_gnutls_strerror(ret));
 
621
          free(buffer.data);
 
622
          buffer.data = NULL;
 
623
        } else {
 
624
          ret = gnutls_openpgp_privkey_import(privkey, &buffer,
 
625
                                            GNUTLS_OPENPGP_FMT_BASE64,
 
626
                                              "", 0);
881
627
          if(ret != GNUTLS_E_SUCCESS){
882
 
            fprintf_plus(stderr, "Error initializing OpenPGP key"
883
 
                         " structure: %s",
 
628
            fprintf_plus(stderr, "Error importing OpenPGP key : %s",
884
629
                         safer_gnutls_strerror(ret));
885
 
            free(buffer.data);
886
 
            buffer.data = NULL;
887
 
          } else {
888
 
            ret = gnutls_openpgp_privkey_import
889
 
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
890
 
            if(ret != GNUTLS_E_SUCCESS){
891
 
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
892
 
                           safer_gnutls_strerror(ret));
893
 
              privkey = NULL;
894
 
            }
895
 
            free(buffer.data);
896
 
            buffer.data = NULL;
897
 
            if(privkey != NULL){
898
 
              /* Use private key to suggest an appropriate
899
 
                 sec_param */
900
 
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
901
 
              gnutls_openpgp_privkey_deinit(privkey);
902
 
              if(debug){
903
 
                fprintf_plus(stderr, "This OpenPGP key implies using"
904
 
                             " a GnuTLS security parameter \"%s\".\n",
905
 
                             safe_string(gnutls_sec_param_get_name
906
 
                                         (sec_param)));
907
 
              }
908
 
            }
 
630
            privkey = NULL;
909
631
          }
910
 
        }
911
 
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
912
 
          /* Err on the side of caution */
913
 
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
914
 
          if(debug){
915
 
            fprintf_plus(stderr, "Falling back to security parameter"
916
 
                         " \"%s\"\n",
917
 
                         safe_string(gnutls_sec_param_get_name
918
 
                                     (sec_param)));
 
632
          free(buffer.data);
 
633
          buffer.data = NULL;
 
634
          if(privkey != NULL){
 
635
            /* Use private key to suggest an appropriate sec_param */
 
636
            sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
637
            gnutls_openpgp_privkey_deinit(privkey);
 
638
            if(debug){
 
639
              fprintf_plus(stderr, "This OpenPGP key implies using a"
 
640
                           " GnuTLS security parameter \"%s\".\n",
 
641
                           safe_string(gnutls_sec_param_get_name
 
642
                                       (sec_param)));
 
643
            }
919
644
          }
920
645
        }
921
646
      }
922
 
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
923
 
      if(uret != 0){
924
 
        mc->dh_bits = uret;
 
647
      if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
648
        /* Err on the side of caution */
 
649
        sec_param = GNUTLS_SEC_PARAM_ULTRA;
925
650
        if(debug){
926
 
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
927
 
                       " implies %u DH bits; using that.\n",
 
651
          fprintf_plus(stderr, "Falling back to security parameter"
 
652
                       " \"%s\"\n",
928
653
                       safe_string(gnutls_sec_param_get_name
929
 
                                   (sec_param)),
930
 
                       mc->dh_bits);
 
654
                                   (sec_param)));
931
655
        }
932
 
      } else {
933
 
        fprintf_plus(stderr, "Failed to get implied number of DH"
934
 
                     " bits for security parameter \"%s\"): %s\n",
 
656
      }
 
657
    }
 
658
    uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
659
    if(uret != 0){
 
660
      mc->dh_bits = uret;
 
661
      if(debug){
 
662
        fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
663
                     " implies %u DH bits; using that.\n",
935
664
                     safe_string(gnutls_sec_param_get_name
936
665
                                 (sec_param)),
937
 
                     safer_gnutls_strerror(ret));
938
 
        goto globalfail;
939
 
      }
940
 
#endif
941
 
    } else {                    /* dh_bits != 0 */
942
 
      if(debug){
943
 
        fprintf_plus(stderr, "DH bits explicitly set to %u\n",
944
666
                     mc->dh_bits);
945
667
      }
946
 
      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
947
 
      if(ret != GNUTLS_E_SUCCESS){
948
 
        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
949
 
                     " bits): %s\n", mc->dh_bits,
950
 
                     safer_gnutls_strerror(ret));
951
 
        goto globalfail;
952
 
      }
953
 
      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
668
    } else {
 
669
      fprintf_plus(stderr, "Failed to get implied number of DH"
 
670
                   " bits for security parameter \"%s\"): %s\n",
 
671
                   safe_string(gnutls_sec_param_get_name(sec_param)),
 
672
                   safer_gnutls_strerror(ret));
 
673
      goto globalfail;
954
674
    }
955
 
  }
 
675
  } else if(debug){
 
676
    fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
677
                 mc->dh_bits);
 
678
  }
 
679
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
680
  if(ret != GNUTLS_E_SUCCESS){
 
681
    fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
 
682
                 " %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
 
683
    goto globalfail;
 
684
  }
 
685
  
 
686
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
956
687
  
957
688
  return 0;
958
689
  
959
690
 globalfail:
960
691
  
961
692
  gnutls_certificate_free_credentials(mc->cred);
 
693
  gnutls_global_deinit();
962
694
  gnutls_dh_params_deinit(mc->dh_params);
963
695
  return -1;
964
696
}
969
701
  int ret;
970
702
  /* GnuTLS session creation */
971
703
  do {
972
 
    ret = gnutls_init(session, (GNUTLS_SERVER
973
 
#if GNUTLS_VERSION_NUMBER >= 0x030506
974
 
                                | GNUTLS_NO_TICKETS
975
 
#endif
976
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
977
 
                                | GNUTLS_ENABLE_RAWPK
978
 
#endif
979
 
                                ));
 
704
    ret = gnutls_init(session, GNUTLS_SERVER);
980
705
    if(quit_now){
981
706
      return -1;
982
707
    }
1023
748
  /* ignore client certificate if any. */
1024
749
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
1025
750
  
 
751
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
 
752
  
1026
753
  return 0;
1027
754
}
1028
755
 
1030
757
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
1031
758
                      __attribute__((unused)) const char *txt){}
1032
759
 
1033
 
/* Helper function to add_local_route() and delete_local_route() */
1034
 
__attribute__((nonnull, warn_unused_result))
1035
 
static bool add_delete_local_route(const bool add,
1036
 
                                   const char *address,
1037
 
                                   AvahiIfIndex if_index){
1038
 
  int ret;
1039
 
  char helper[] = "mandos-client-iprouteadddel";
1040
 
  char add_arg[] = "add";
1041
 
  char delete_arg[] = "delete";
1042
 
  char debug_flag[] = "--debug";
1043
 
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1044
 
  if(pluginhelperdir == NULL){
1045
 
    if(debug){
1046
 
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1047
 
                   " variable not set; cannot run helper\n");
1048
 
    }
1049
 
    return false;
1050
 
  }
1051
 
  
1052
 
  char interface[IF_NAMESIZE];
1053
 
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
1054
 
    perror_plus("if_indextoname");
1055
 
    return false;
1056
 
  }
1057
 
  
1058
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1059
 
  if(devnull == -1){
1060
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
1061
 
    return false;
1062
 
  }
1063
 
  pid_t pid = fork();
1064
 
  if(pid == 0){
1065
 
    /* Child */
1066
 
    /* Raise privileges */
1067
 
    errno = raise_privileges_permanently();
1068
 
    if(errno != 0){
1069
 
      perror_plus("Failed to raise privileges");
1070
 
      /* _exit(EX_NOPERM); */
1071
 
    } else {
1072
 
      /* Set group */
1073
 
      errno = 0;
1074
 
      ret = setgid(0);
1075
 
      if(ret == -1){
1076
 
        perror_plus("setgid");
1077
 
        close(devnull);
1078
 
        _exit(EX_NOPERM);
1079
 
      }
1080
 
      /* Reset supplementary groups */
1081
 
      errno = 0;
1082
 
      ret = setgroups(0, NULL);
1083
 
      if(ret == -1){
1084
 
        perror_plus("setgroups");
1085
 
        close(devnull);
1086
 
        _exit(EX_NOPERM);
1087
 
      }
1088
 
    }
1089
 
    ret = dup2(devnull, STDIN_FILENO);
1090
 
    if(ret == -1){
1091
 
      perror_plus("dup2(devnull, STDIN_FILENO)");
1092
 
      close(devnull);
1093
 
      _exit(EX_OSERR);
1094
 
    }
1095
 
    ret = close(devnull);
1096
 
    if(ret == -1){
1097
 
      perror_plus("close");
1098
 
    }
1099
 
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1100
 
    if(ret == -1){
1101
 
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1102
 
      _exit(EX_OSERR);
1103
 
    }
1104
 
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1105
 
                                                    O_RDONLY
1106
 
                                                    | O_DIRECTORY
1107
 
                                                    | O_PATH
1108
 
                                                    | O_CLOEXEC));
1109
 
    if(helperdir_fd == -1){
1110
 
      perror_plus("open");
1111
 
      _exit(EX_UNAVAILABLE);
1112
 
    }
1113
 
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1114
 
                                                   helper, O_RDONLY));
1115
 
    if(helper_fd == -1){
1116
 
      perror_plus("openat");
1117
 
      close(helperdir_fd);
1118
 
      _exit(EX_UNAVAILABLE);
1119
 
    }
1120
 
    close(helperdir_fd);
1121
 
#ifdef __GNUC__
1122
 
#pragma GCC diagnostic push
1123
 
#pragma GCC diagnostic ignored "-Wcast-qual"
1124
 
#endif
1125
 
    if(fexecve(helper_fd, (char *const [])
1126
 
               { helper, add ? add_arg : delete_arg, (char *)address,
1127
 
                   interface, debug ? debug_flag : NULL, NULL },
1128
 
               environ) == -1){
1129
 
#ifdef __GNUC__
1130
 
#pragma GCC diagnostic pop
1131
 
#endif
1132
 
      perror_plus("fexecve");
1133
 
      _exit(EXIT_FAILURE);
1134
 
    }
1135
 
  }
1136
 
  if(pid == -1){
1137
 
    perror_plus("fork");
1138
 
    close(devnull);
1139
 
    return false;
1140
 
  }
1141
 
  ret = close(devnull);
1142
 
  if(ret == -1){
1143
 
    perror_plus("close");
1144
 
  }
1145
 
  int status;
1146
 
  pid_t pret = -1;
1147
 
  errno = 0;
1148
 
  do {
1149
 
    pret = waitpid(pid, &status, 0);
1150
 
    if(pret == -1 and errno == EINTR and quit_now){
1151
 
      int errno_raising = 0;
1152
 
      if((errno = raise_privileges()) != 0){
1153
 
        errno_raising = errno;
1154
 
        perror_plus("Failed to raise privileges in order to"
1155
 
                    " kill helper program");
1156
 
      }
1157
 
      if(kill(pid, SIGTERM) == -1){
1158
 
        perror_plus("kill");
1159
 
      }
1160
 
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1161
 
        perror_plus("Failed to lower privileges after killing"
1162
 
                    " helper program");
1163
 
      }
1164
 
      return false;
1165
 
    }
1166
 
  } while(pret == -1 and errno == EINTR);
1167
 
  if(pret == -1){
1168
 
    perror_plus("waitpid");
1169
 
    return false;
1170
 
  }
1171
 
  if(WIFEXITED(status)){
1172
 
    if(WEXITSTATUS(status) != 0){
1173
 
      fprintf_plus(stderr, "Error: iprouteadddel exited"
1174
 
                   " with status %d\n", WEXITSTATUS(status));
1175
 
      return false;
1176
 
    }
1177
 
    return true;
1178
 
  }
1179
 
  if(WIFSIGNALED(status)){
1180
 
    fprintf_plus(stderr, "Error: iprouteadddel died by"
1181
 
                 " signal %d\n", WTERMSIG(status));
1182
 
    return false;
1183
 
  }
1184
 
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1185
 
  return false;
1186
 
}
1187
 
 
1188
 
__attribute__((nonnull, warn_unused_result))
1189
 
static bool add_local_route(const char *address,
1190
 
                            AvahiIfIndex if_index){
1191
 
  if(debug){
1192
 
    fprintf_plus(stderr, "Adding route to %s\n", address);
1193
 
  }
1194
 
  return add_delete_local_route(true, address, if_index);
1195
 
}
1196
 
 
1197
 
__attribute__((nonnull, warn_unused_result))
1198
 
static bool delete_local_route(const char *address,
1199
 
                               AvahiIfIndex if_index){
1200
 
  if(debug){
1201
 
    fprintf_plus(stderr, "Removing route to %s\n", address);
1202
 
  }
1203
 
  return add_delete_local_route(false, address, if_index);
1204
 
}
1205
 
 
1206
760
/* Called when a Mandos server is found */
1207
761
__attribute__((nonnull, warn_unused_result))
1208
762
static int start_mandos_communication(const char *ip, in_port_t port,
1219
773
  int retval = -1;
1220
774
  gnutls_session_t session;
1221
775
  int pf;                       /* Protocol family */
1222
 
  bool route_added = false;
1223
776
  
1224
777
  errno = 0;
1225
778
  
1247
800
    bool match = false;
1248
801
    {
1249
802
      char *interface = NULL;
1250
 
      while((interface = argz_next(mc->interfaces,
1251
 
                                   mc->interfaces_size,
1252
 
                                   interface))){
 
803
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
804
                                 interface))){
1253
805
        if(if_nametoindex(interface) == (unsigned int)if_index){
1254
806
          match = true;
1255
807
          break;
1284
836
                 PRIuMAX "\n", ip, (uintmax_t)port);
1285
837
  }
1286
838
  
1287
 
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
 
839
  tcp_sd = socket(pf, SOCK_STREAM, 0);
1288
840
  if(tcp_sd < 0){
1289
841
    int e = errno;
1290
842
    perror_plus("socket");
1297
849
    goto mandos_end;
1298
850
  }
1299
851
  
 
852
  memset(&to, 0, sizeof(to));
1300
853
  if(af == AF_INET6){
1301
 
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1302
 
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1303
 
    ret = inet_pton(af, ip, &to6->sin6_addr);
 
854
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
 
855
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1304
856
  } else {                      /* IPv4 */
1305
 
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1306
 
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1307
 
    ret = inet_pton(af, ip, &to4->sin_addr);
 
857
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
 
858
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1308
859
  }
1309
860
  if(ret < 0 ){
1310
861
    int e = errno;
1380
931
    goto mandos_end;
1381
932
  }
1382
933
  
1383
 
  while(true){
1384
 
    if(af == AF_INET6){
1385
 
      ret = connect(tcp_sd, (struct sockaddr *)&to,
1386
 
                    sizeof(struct sockaddr_in6));
1387
 
    } else {
1388
 
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1389
 
                    sizeof(struct sockaddr_in));
1390
 
    }
1391
 
    if(ret < 0){
1392
 
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1393
 
         and if_index != AVAHI_IF_UNSPEC
1394
 
         and connect_to == NULL
1395
 
         and not route_added and
1396
 
         ((af == AF_INET6 and not
1397
 
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1398
 
                                    &to)->sin6_addr)))
1399
 
          or (af == AF_INET and
1400
 
              /* Not a a IPv4LL address */
1401
 
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1402
 
               & 0xFFFF0000L) != 0xA9FE0000L))){
1403
 
        /* Work around Avahi bug - Avahi does not announce link-local
1404
 
           addresses if it has a global address, so local hosts with
1405
 
           *only* a link-local address (e.g. Mandos clients) cannot
1406
 
           connect to a Mandos server announced by Avahi on a server
1407
 
           host with a global address.  Work around this by retrying
1408
 
           with an explicit route added with the server's address.
1409
 
           
1410
 
           Avahi bug reference:
1411
 
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1412
 
           https://bugs.debian.org/587961
1413
 
        */
1414
 
        if(debug){
1415
 
          fprintf_plus(stderr, "Mandos server unreachable, trying"
1416
 
                       " direct route\n");
1417
 
        }
1418
 
        int e = errno;
1419
 
        route_added = add_local_route(ip, if_index);
1420
 
        if(route_added){
1421
 
          continue;
1422
 
        }
1423
 
        errno = e;
1424
 
      }
1425
 
      if(errno != ECONNREFUSED or debug){
1426
 
        int e = errno;
1427
 
        perror_plus("connect");
1428
 
        errno = e;
1429
 
      }
1430
 
      goto mandos_end;
1431
 
    }
1432
 
    
1433
 
    if(quit_now){
1434
 
      errno = EINTR;
1435
 
      goto mandos_end;
1436
 
    }
1437
 
    break;
 
934
  if(af == AF_INET6){
 
935
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
936
                  sizeof(struct sockaddr_in6));
 
937
  } else {
 
938
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
939
                  sizeof(struct sockaddr_in));
 
940
  }
 
941
  if(ret < 0){
 
942
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
943
      int e = errno;
 
944
      perror_plus("connect");
 
945
      errno = e;
 
946
    }
 
947
    goto mandos_end;
 
948
  }
 
949
  
 
950
  if(quit_now){
 
951
    errno = EINTR;
 
952
    goto mandos_end;
1438
953
  }
1439
954
  
1440
955
  const char *out = mandos_protocol_version;
1594
1109
                                               &decrypted_buffer, mc);
1595
1110
    if(decrypted_buffer_size >= 0){
1596
1111
      
1597
 
      clearerr(stdout);
1598
1112
      written = 0;
1599
1113
      while(written < (size_t) decrypted_buffer_size){
1600
1114
        if(quit_now){
1616
1130
        }
1617
1131
        written += (size_t)ret;
1618
1132
      }
1619
 
      ret = fflush(stdout);
1620
 
      if(ret != 0){
1621
 
        int e = errno;
1622
 
        if(debug){
1623
 
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1624
 
                       strerror(errno));
1625
 
        }
1626
 
        errno = e;
1627
 
        goto mandos_end;
1628
 
      }
1629
1133
      retval = 0;
1630
1134
    }
1631
1135
  }
1634
1138
  
1635
1139
 mandos_end:
1636
1140
  {
1637
 
    if(route_added){
1638
 
      if(not delete_local_route(ip, if_index)){
1639
 
        fprintf_plus(stderr, "Failed to delete local route to %s on"
1640
 
                     " interface %d", ip, if_index);
1641
 
      }
1642
 
    }
1643
1141
    int e = errno;
1644
1142
    free(decrypted_buffer);
1645
1143
    free(buffer);
1646
1144
    if(tcp_sd >= 0){
1647
 
      ret = close(tcp_sd);
 
1145
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1648
1146
    }
1649
1147
    if(ret == -1){
1650
1148
      if(e == 0){
1662
1160
  return retval;
1663
1161
}
1664
1162
 
 
1163
__attribute__((nonnull))
1665
1164
static void resolve_callback(AvahiSServiceResolver *r,
1666
1165
                             AvahiIfIndex interface,
1667
1166
                             AvahiProtocol proto,
1804
1303
__attribute__((nonnull, warn_unused_result))
1805
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1806
1305
  int ret;
1807
 
  int old_errno;
 
1306
  error_t ret_errno;
1808
1307
  
1809
1308
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1810
1309
  if(s < 0){
1811
 
    old_errno = errno;
 
1310
    ret_errno = errno;
1812
1311
    perror_plus("socket");
1813
 
    errno = old_errno;
 
1312
    errno = ret_errno;
1814
1313
    return false;
1815
1314
  }
1816
 
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1817
 
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
 
1315
  strcpy(ifr->ifr_name, ifname);
1818
1316
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1819
1317
  if(ret == -1){
1820
1318
    if(debug){
1821
 
      old_errno = errno;
 
1319
      ret_errno = errno;
1822
1320
      perror_plus("ioctl SIOCGIFFLAGS");
1823
 
      errno = old_errno;
1824
 
    }
1825
 
    if((close(s) == -1) and debug){
1826
 
      old_errno = errno;
1827
 
      perror_plus("close");
1828
 
      errno = old_errno;
 
1321
      errno = ret_errno;
1829
1322
    }
1830
1323
    return false;
1831
1324
  }
1832
 
  if((close(s) == -1) and debug){
1833
 
    old_errno = errno;
1834
 
    perror_plus("close");
1835
 
    errno = old_errno;
1836
 
  }
1837
1325
  return true;
1838
1326
}
1839
1327
 
2081
1569
  }
2082
1570
}
2083
1571
 
 
1572
/* Set effective uid to 0, return errno */
 
1573
__attribute__((warn_unused_result))
 
1574
error_t raise_privileges(void){
 
1575
  error_t old_errno = errno;
 
1576
  error_t ret_errno = 0;
 
1577
  if(seteuid(0) == -1){
 
1578
    ret_errno = errno;
 
1579
  }
 
1580
  errno = old_errno;
 
1581
  return ret_errno;
 
1582
}
 
1583
 
 
1584
/* Set effective and real user ID to 0.  Return errno. */
 
1585
__attribute__((warn_unused_result))
 
1586
error_t raise_privileges_permanently(void){
 
1587
  error_t old_errno = errno;
 
1588
  error_t ret_errno = raise_privileges();
 
1589
  if(ret_errno != 0){
 
1590
    errno = old_errno;
 
1591
    return ret_errno;
 
1592
  }
 
1593
  if(setuid(0) == -1){
 
1594
    ret_errno = errno;
 
1595
  }
 
1596
  errno = old_errno;
 
1597
  return ret_errno;
 
1598
}
 
1599
 
 
1600
/* Set effective user ID to unprivileged saved user ID */
 
1601
__attribute__((warn_unused_result))
 
1602
error_t lower_privileges(void){
 
1603
  error_t old_errno = errno;
 
1604
  error_t ret_errno = 0;
 
1605
  if(seteuid(uid) == -1){
 
1606
    ret_errno = errno;
 
1607
  }
 
1608
  errno = old_errno;
 
1609
  return ret_errno;
 
1610
}
 
1611
 
 
1612
/* Lower privileges permanently */
 
1613
__attribute__((warn_unused_result))
 
1614
error_t lower_privileges_permanently(void){
 
1615
  error_t old_errno = errno;
 
1616
  error_t ret_errno = 0;
 
1617
  if(setuid(uid) == -1){
 
1618
    ret_errno = errno;
 
1619
  }
 
1620
  errno = old_errno;
 
1621
  return ret_errno;
 
1622
}
 
1623
 
2084
1624
__attribute__((nonnull))
2085
1625
void run_network_hooks(const char *mode, const char *interface,
2086
1626
                       const float delay){
2087
1627
  struct dirent **direntries = NULL;
2088
1628
  if(hookdir_fd == -1){
2089
 
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2090
 
                      | O_CLOEXEC);
 
1629
    hookdir_fd = open(hookdir, O_RDONLY);
2091
1630
    if(hookdir_fd == -1){
2092
1631
      if(errno == ENOENT){
2093
1632
        if(debug){
2100
1639
      return;
2101
1640
    }
2102
1641
  }
2103
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2104
 
  if(devnull == -1){
2105
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
2106
 
    return;
2107
 
  }
 
1642
#ifdef __GLIBC__
 
1643
#if __GLIBC_PREREQ(2, 15)
2108
1644
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
2109
1645
                           runnable_hook, alphasort);
 
1646
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1647
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1648
                         alphasort);
 
1649
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1650
#else   /* not __GLIBC__ */
 
1651
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1652
                         alphasort);
 
1653
#endif  /* not __GLIBC__ */
2110
1654
  if(numhooks == -1){
2111
1655
    perror_plus("scandir");
2112
 
    close(devnull);
2113
1656
    return;
2114
1657
  }
2115
1658
  struct dirent *direntry;
2116
1659
  int ret;
 
1660
  int devnull = open("/dev/null", O_RDONLY);
2117
1661
  for(int i = 0; i < numhooks; i++){
2118
1662
    direntry = direntries[i];
2119
1663
    if(debug){
2143
1687
        perror_plus("setgroups");
2144
1688
        _exit(EX_NOPERM);
2145
1689
      }
 
1690
      ret = dup2(devnull, STDIN_FILENO);
 
1691
      if(ret == -1){
 
1692
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
1693
        _exit(EX_OSERR);
 
1694
      }
 
1695
      ret = close(devnull);
 
1696
      if(ret == -1){
 
1697
        perror_plus("close");
 
1698
        _exit(EX_OSERR);
 
1699
      }
 
1700
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1701
      if(ret == -1){
 
1702
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1703
        _exit(EX_OSERR);
 
1704
      }
2146
1705
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2147
1706
      if(ret == -1){
2148
1707
        perror_plus("setenv");
2183
1742
          _exit(EX_OSERR);
2184
1743
        }
2185
1744
      }
2186
 
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2187
 
                                                   direntry->d_name,
2188
 
                                                   O_RDONLY));
 
1745
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2189
1746
      if(hook_fd == -1){
2190
1747
        perror_plus("openat");
2191
1748
        _exit(EXIT_FAILURE);
2192
1749
      }
2193
 
      if(close(hookdir_fd) == -1){
 
1750
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2194
1751
        perror_plus("close");
2195
1752
        _exit(EXIT_FAILURE);
2196
1753
      }
2197
 
      ret = dup2(devnull, STDIN_FILENO);
2198
 
      if(ret == -1){
2199
 
        perror_plus("dup2(devnull, STDIN_FILENO)");
2200
 
        _exit(EX_OSERR);
2201
 
      }
2202
 
      ret = close(devnull);
2203
 
      if(ret == -1){
2204
 
        perror_plus("close");
2205
 
        _exit(EX_OSERR);
2206
 
      }
2207
 
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2208
 
      if(ret == -1){
2209
 
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2210
 
        _exit(EX_OSERR);
2211
 
      }
2212
1754
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2213
1755
                 environ) == -1){
2214
1756
        perror_plus("fexecve");
2254
1796
    free(direntry);
2255
1797
  }
2256
1798
  free(direntries);
2257
 
  if(close(hookdir_fd) == -1){
 
1799
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2258
1800
    perror_plus("close");
2259
1801
  } else {
2260
1802
    hookdir_fd = -1;
2263
1805
}
2264
1806
 
2265
1807
__attribute__((nonnull, warn_unused_result))
2266
 
int bring_up_interface(const char *const interface,
2267
 
                       const float delay){
2268
 
  int old_errno = errno;
 
1808
error_t bring_up_interface(const char *const interface,
 
1809
                           const float delay){
 
1810
  error_t old_errno = errno;
2269
1811
  int ret;
2270
1812
  struct ifreq network;
2271
1813
  unsigned int if_index = if_nametoindex(interface);
2281
1823
  }
2282
1824
  
2283
1825
  if(not interface_is_up(interface)){
2284
 
    int ret_errno = 0;
2285
 
    int ioctl_errno = 0;
 
1826
    error_t ret_errno = 0, ioctl_errno = 0;
2286
1827
    if(not get_flags(interface, &network)){
2287
1828
      ret_errno = errno;
2288
1829
      fprintf_plus(stderr, "Failed to get flags for interface "
2301
1842
    }
2302
1843
    
2303
1844
    if(quit_now){
2304
 
      ret = close(sd);
 
1845
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2305
1846
      if(ret == -1){
2306
1847
        perror_plus("close");
2307
1848
      }
2357
1898
    }
2358
1899
    
2359
1900
    /* Close the socket */
2360
 
    ret = close(sd);
 
1901
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
2361
1902
    if(ret == -1){
2362
1903
      perror_plus("close");
2363
1904
    }
2375
1916
  
2376
1917
  /* Sleep checking until interface is running.
2377
1918
     Check every 0.25s, up to total time of delay */
2378
 
  for(int i = 0; i < delay * 4; i++){
 
1919
  for(int i=0; i < delay * 4; i++){
2379
1920
    if(interface_is_running(interface)){
2380
1921
      break;
2381
1922
    }
2391
1932
}
2392
1933
 
2393
1934
__attribute__((nonnull, warn_unused_result))
2394
 
int take_down_interface(const char *const interface){
2395
 
  int old_errno = errno;
 
1935
error_t take_down_interface(const char *const interface){
 
1936
  error_t old_errno = errno;
2396
1937
  struct ifreq network;
2397
1938
  unsigned int if_index = if_nametoindex(interface);
2398
1939
  if(if_index == 0){
2401
1942
    return ENXIO;
2402
1943
  }
2403
1944
  if(interface_is_up(interface)){
2404
 
    int ret_errno = 0;
2405
 
    int ioctl_errno = 0;
 
1945
    error_t ret_errno = 0, ioctl_errno = 0;
2406
1946
    if(not get_flags(interface, &network) and debug){
2407
1947
      ret_errno = errno;
2408
1948
      fprintf_plus(stderr, "Failed to get flags for interface "
2446
1986
    }
2447
1987
    
2448
1988
    /* Close the socket */
2449
 
    int ret = close(sd);
 
1989
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2450
1990
    if(ret == -1){
2451
1991
      perror_plus("close");
2452
1992
    }
2468
2008
 
2469
2009
int main(int argc, char *argv[]){
2470
2010
  mandos_context mc = { .server = NULL, .dh_bits = 0,
2471
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2472
 
                        .priority = "SECURE128:!CTYPE-X.509"
2473
 
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2474
 
                        ":%PROFILE_ULTRA",
2475
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
2476
 
                        .priority = "SECURE256:!CTYPE-X.509"
2477
 
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2478
 
#else
2479
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2480
 
#endif
2481
 
                        .current_server = NULL, .interfaces = NULL,
2482
 
                        .interfaces_size = 0 };
 
2011
                        .priority = "SECURE256:!CTYPE-X.509:"
 
2012
                        "+CTYPE-OPENPGP:!RSA", .current_server = NULL,
 
2013
                        .interfaces = NULL, .interfaces_size = 0 };
2483
2014
  AvahiSServiceBrowser *sb = NULL;
2484
2015
  error_t ret_errno;
2485
2016
  int ret;
2494
2025
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2495
2026
  const char *seckey = PATHDIR "/" SECKEY;
2496
2027
  const char *pubkey = PATHDIR "/" PUBKEY;
2497
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2498
 
  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2499
 
  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2500
 
#endif
2501
 
  const char *dh_params_file = NULL;
2502
2028
  char *interfaces_hooks = NULL;
2503
2029
  
2504
2030
  bool gnutls_initialized = false;
2551
2077
      { .name = "pubkey", .key = 'p',
2552
2078
        .arg = "FILE",
2553
2079
        .doc = "OpenPGP public key file base name",
2554
 
        .group = 1 },
2555
 
      { .name = "tls-privkey", .key = 't',
2556
 
        .arg = "FILE",
2557
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2558
 
        .doc = "TLS private key file base name",
2559
 
#else
2560
 
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2561
 
#endif
2562
 
        .group = 1 },
2563
 
      { .name = "tls-pubkey", .key = 'T',
2564
 
        .arg = "FILE",
2565
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2566
 
        .doc = "TLS public key file base name",
2567
 
#else
2568
 
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2569
 
#endif
2570
 
        .group = 1 },
 
2080
        .group = 2 },
2571
2081
      { .name = "dh-bits", .key = 129,
2572
2082
        .arg = "BITS",
2573
2083
        .doc = "Bit length of the prime number used in the"
2574
2084
        " Diffie-Hellman key exchange",
2575
2085
        .group = 2 },
2576
 
      { .name = "dh-params", .key = 134,
2577
 
        .arg = "FILE",
2578
 
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2579
 
        " for the Diffie-Hellman key exchange",
2580
 
        .group = 2 },
2581
2086
      { .name = "priority", .key = 130,
2582
2087
        .arg = "STRING",
2583
2088
        .doc = "GnuTLS priority string for the TLS handshake",
2629
2134
      case 'p':                 /* --pubkey */
2630
2135
        pubkey = arg;
2631
2136
        break;
2632
 
      case 't':                 /* --tls-privkey */
2633
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2634
 
        tls_privkey = arg;
2635
 
#endif
2636
 
        break;
2637
 
      case 'T':                 /* --tls-pubkey */
2638
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2639
 
        tls_pubkey = arg;
2640
 
#endif
2641
 
        break;
2642
2137
      case 129:                 /* --dh-bits */
2643
2138
        errno = 0;
2644
2139
        tmpmax = strtoimax(arg, &tmp, 10);
2648
2143
        }
2649
2144
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2650
2145
        break;
2651
 
      case 134:                 /* --dh-params */
2652
 
        dh_params_file = arg;
2653
 
        break;
2654
2146
      case 130:                 /* --priority */
2655
2147
        mc.priority = arg;
2656
2148
        break;
2679
2171
        argp_state_help(state, state->out_stream,
2680
2172
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2681
2173
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
2682
 
        __builtin_unreachable();
2683
2174
      case -3:                  /* --usage */
2684
2175
        argp_state_help(state, state->out_stream,
2685
2176
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2686
 
        __builtin_unreachable();
2687
2177
      case 'V':                 /* --version */
2688
2178
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2689
2179
        exit(argp_err_exit_status);
2698
2188
                         .args_doc = "",
2699
2189
                         .doc = "Mandos client -- Get and decrypt"
2700
2190
                         " passwords from a Mandos server" };
2701
 
    ret_errno = argp_parse(&argp, argc, argv,
2702
 
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2703
 
    switch(ret_errno){
 
2191
    ret = argp_parse(&argp, argc, argv,
 
2192
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2193
    switch(ret){
2704
2194
    case 0:
2705
2195
      break;
2706
2196
    case ENOMEM:
2707
2197
    default:
2708
 
      errno = ret_errno;
 
2198
      errno = ret;
2709
2199
      perror_plus("argp_parse");
2710
2200
      exitcode = EX_OSERR;
2711
2201
      goto end;
2714
2204
      goto end;
2715
2205
    }
2716
2206
  }
2717
 
  
 
2207
    
2718
2208
  {
2719
2209
    /* Work around Debian bug #633582:
2720
 
       <https://bugs.debian.org/633582> */
 
2210
       <http://bugs.debian.org/633582> */
2721
2211
    
2722
2212
    /* Re-raise privileges */
2723
 
    ret = raise_privileges();
2724
 
    if(ret != 0){
2725
 
      errno = ret;
 
2213
    ret_errno = raise_privileges();
 
2214
    if(ret_errno != 0){
 
2215
      errno = ret_errno;
2726
2216
      perror_plus("Failed to raise privileges");
2727
2217
    } else {
2728
2218
      struct stat st;
2744
2234
              }
2745
2235
            }
2746
2236
          }
2747
 
          close(seckey_fd);
 
2237
          TEMP_FAILURE_RETRY(close(seckey_fd));
2748
2238
        }
2749
2239
      }
2750
 
      
 
2240
    
2751
2241
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2752
2242
        int pubkey_fd = open(pubkey, O_RDONLY);
2753
2243
        if(pubkey_fd == -1){
2765
2255
              }
2766
2256
            }
2767
2257
          }
2768
 
          close(pubkey_fd);
2769
 
        }
2770
 
      }
2771
 
      
2772
 
      if(dh_params_file != NULL
2773
 
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2774
 
        int dhparams_fd = open(dh_params_file, O_RDONLY);
2775
 
        if(dhparams_fd == -1){
2776
 
          perror_plus("open");
2777
 
        } else {
2778
 
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2779
 
          if(ret == -1){
2780
 
            perror_plus("fstat");
2781
 
          } else {
2782
 
            if(S_ISREG(st.st_mode)
2783
 
               and st.st_uid == 0 and st.st_gid == 0){
2784
 
              ret = fchown(dhparams_fd, uid, gid);
2785
 
              if(ret == -1){
2786
 
                perror_plus("fchown");
2787
 
              }
2788
 
            }
2789
 
          }
2790
 
          close(dhparams_fd);
2791
 
        }
2792
 
      }
2793
 
      
 
2258
          TEMP_FAILURE_RETRY(close(pubkey_fd));
 
2259
        }
 
2260
      }
 
2261
    
2794
2262
      /* Lower privileges */
2795
 
      ret = lower_privileges();
2796
 
      if(ret != 0){
2797
 
        errno = ret;
 
2263
      ret_errno = lower_privileges();
 
2264
      if(ret_errno != 0){
 
2265
        errno = ret_errno;
2798
2266
        perror_plus("Failed to lower privileges");
2799
2267
      }
2800
2268
    }
2970
2438
      errno = bring_up_interface(interface, delay);
2971
2439
      if(not interface_was_up){
2972
2440
        if(errno != 0){
2973
 
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2974
 
                       " %s\n", interface, strerror(errno));
 
2441
          perror_plus("Failed to bring up interface");
2975
2442
        } else {
2976
2443
          errno = argz_add(&interfaces_to_take_down,
2977
2444
                           &interfaces_to_take_down_size,
3000
2467
    goto end;
3001
2468
  }
3002
2469
  
3003
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
3004
 
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
3005
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
3006
 
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3007
 
#else
3008
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3009
 
#endif
 
2470
  ret = init_gnutls_global(pubkey, seckey, &mc);
3010
2471
  if(ret == -1){
3011
2472
    fprintf_plus(stderr, "init_gnutls_global failed\n");
3012
2473
    exitcode = EX_UNAVAILABLE;
3134
2595
    
3135
2596
    /* Allocate a new server */
3136
2597
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3137
 
                                 &config, NULL, NULL, &ret);
 
2598
                                 &config, NULL, NULL, &ret_errno);
3138
2599
    
3139
2600
    /* Free the Avahi configuration data */
3140
2601
    avahi_server_config_free(&config);
3143
2604
  /* Check if creating the Avahi server object succeeded */
3144
2605
  if(mc.server == NULL){
3145
2606
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3146
 
                 avahi_strerror(ret));
 
2607
                 avahi_strerror(ret_errno));
3147
2608
    exitcode = EX_UNAVAILABLE;
3148
2609
    goto end;
3149
2610
  }
3184
2645
 end:
3185
2646
  
3186
2647
  if(debug){
3187
 
    if(signal_received){
3188
 
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3189
 
                   argv[0], signal_received,
3190
 
                   strsignal(signal_received));
3191
 
    } else {
3192
 
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
3193
 
    }
 
2648
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
3194
2649
  }
3195
2650
  
3196
2651
  /* Cleanup things */
3207
2662
  
3208
2663
  if(gnutls_initialized){
3209
2664
    gnutls_certificate_free_credentials(mc.cred);
 
2665
    gnutls_global_deinit();
3210
2666
    gnutls_dh_params_deinit(mc.dh_params);
3211
2667
  }
3212
2668
  
3235
2691
  
3236
2692
  /* Re-raise privileges */
3237
2693
  {
3238
 
    ret = raise_privileges();
3239
 
    if(ret != 0){
3240
 
      errno = ret;
 
2694
    ret_errno = raise_privileges();
 
2695
    if(ret_errno != 0){
 
2696
      errno = ret_errno;
3241
2697
      perror_plus("Failed to raise privileges");
3242
2698
    } else {
3243
2699
      
3248
2704
      /* Take down the network interfaces which were brought up */
3249
2705
      {
3250
2706
        char *interface = NULL;
3251
 
        while((interface = argz_next(interfaces_to_take_down,
3252
 
                                     interfaces_to_take_down_size,
3253
 
                                     interface))){
3254
 
          ret = take_down_interface(interface);
3255
 
          if(ret != 0){
3256
 
            errno = ret;
 
2707
        while((interface=argz_next(interfaces_to_take_down,
 
2708
                                   interfaces_to_take_down_size,
 
2709
                                   interface))){
 
2710
          ret_errno = take_down_interface(interface);
 
2711
          if(ret_errno != 0){
 
2712
            errno = ret_errno;
3257
2713
            perror_plus("Failed to take down interface");
3258
2714
          }
3259
2715
        }
3264
2720
      }
3265
2721
    }
3266
2722
    
3267
 
    ret = lower_privileges_permanently();
3268
 
    if(ret != 0){
3269
 
      errno = ret;
 
2723
    ret_errno = lower_privileges_permanently();
 
2724
    if(ret_errno != 0){
 
2725
      errno = ret_errno;
3270
2726
      perror_plus("Failed to lower privileges permanently");
3271
2727
    }
3272
2728
  }
3274
2730
  free(interfaces_to_take_down);
3275
2731
  free(interfaces_hooks);
3276
2732
  
3277
 
  void clean_dir_at(int base, const char * const dirname,
3278
 
                    uintmax_t level){
3279
 
    struct dirent **direntries = NULL;
3280
 
    int dret;
3281
 
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3282
 
                                                O_RDONLY
3283
 
                                                | O_NOFOLLOW
3284
 
                                                | O_DIRECTORY
3285
 
                                                | O_PATH));
3286
 
    if(dir_fd == -1){
3287
 
      perror_plus("open");
3288
 
      return;
3289
 
    }
3290
 
    int numentries = scandirat(dir_fd, ".", &direntries,
3291
 
                               notdotentries, alphasort);
3292
 
    if(numentries >= 0){
3293
 
      for(int i = 0; i < numentries; i++){
3294
 
        if(debug){
3295
 
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3296
 
                       dirname, direntries[i]->d_name);
3297
 
        }
3298
 
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3299
 
        if(dret == -1){
3300
 
          if(errno == EISDIR){
3301
 
              dret = unlinkat(dir_fd, direntries[i]->d_name,
3302
 
                              AT_REMOVEDIR);
3303
 
          }         
3304
 
          if((dret == -1) and (errno == ENOTEMPTY)
3305
 
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3306
 
                  == 0) and (level == 0)){
3307
 
            /* Recurse only in this special case */
3308
 
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3309
 
            dret = 0;
3310
 
          }
3311
 
          if((dret == -1) and (errno != ENOENT)){
3312
 
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3313
 
                         direntries[i]->d_name, strerror(errno));
3314
 
          }
3315
 
        }
3316
 
        free(direntries[i]);
3317
 
      }
3318
 
      
3319
 
      /* need to clean even if 0 because man page doesn't specify */
3320
 
      free(direntries);
3321
 
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
3322
 
      if(dret == -1 and errno != ENOENT){
3323
 
        perror_plus("rmdir");
3324
 
      }
3325
 
    } else {
3326
 
      perror_plus("scandirat");
3327
 
    }
3328
 
    close(dir_fd);
3329
 
  }
3330
 
  
3331
2733
  /* Removes the GPGME temp directory and all files inside */
3332
2734
  if(tempdir != NULL){
3333
 
    clean_dir_at(-1, tempdir, 0);
 
2735
    struct dirent **direntries = NULL;
 
2736
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
 
2737
                                                  O_NOFOLLOW));
 
2738
    if(tempdir_fd == -1){
 
2739
      perror_plus("open");
 
2740
    } else {
 
2741
#ifdef __GLIBC__
 
2742
#if __GLIBC_PREREQ(2, 15)
 
2743
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
2744
                                 notdotentries, alphasort);
 
2745
#else  /* not __GLIBC_PREREQ(2, 15) */
 
2746
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2747
                               alphasort);
 
2748
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
2749
#else   /* not __GLIBC__ */
 
2750
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2751
                               alphasort);
 
2752
#endif  /* not __GLIBC__ */
 
2753
      if(numentries >= 0){
 
2754
        for(int i = 0; i < numentries; i++){
 
2755
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
2756
          if(ret == -1){
 
2757
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
2758
                         " \"%s\", 0): %s\n", tempdir,
 
2759
                         direntries[i]->d_name, strerror(errno));
 
2760
          }
 
2761
          free(direntries[i]);
 
2762
        }
 
2763
        
 
2764
        /* need to clean even if 0 because man page doesn't specify */
 
2765
        free(direntries);
 
2766
        if(numentries == -1){
 
2767
          perror_plus("scandir");
 
2768
        }
 
2769
        ret = rmdir(tempdir);
 
2770
        if(ret == -1 and errno != ENOENT){
 
2771
          perror_plus("rmdir");
 
2772
        }
 
2773
      }
 
2774
      TEMP_FAILURE_RETRY(close(tempdir_fd));
 
2775
    }
3334
2776
  }
3335
2777
  
3336
2778
  if(quit_now){