/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-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
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-2015 Teddy Hogeborn
 
13
 * Copyright © 2008-2015 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
 */
48
47
                                   strtof(), abort() */
49
48
#include <stdbool.h>            /* bool, false, true */
50
49
#include <string.h>             /* strcmp(), strlen(), strerror(),
51
 
                                   asprintf(), strncpy(), strsignal()
52
 
                                */
 
50
                                   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
 
      if(clock_settime(CLOCK_REALTIME, &keystat.st_mtim) != 0){
400
 
        perror_plus("clock_settime");
401
 
      }
402
 
      ret = lower_privileges();
403
 
      if(ret != 0){
404
 
        errno = ret;
405
 
        perror_plus("Failed to lower privileges");
406
 
      }
407
 
    } while(false);
408
 
 
409
294
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
410
295
    if(rc != GPG_ERR_NO_ERROR){
411
296
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
419
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
420
305
      return false;
421
306
    }
422
 
    {
423
 
      gpgme_import_result_t import_result
424
 
        = gpgme_op_import_result(mc->ctx);
425
 
      if((import_result->imported < 1
426
 
          or import_result->not_imported > 0)
427
 
         and import_result->unchanged == 0){
428
 
        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
429
 
        fprintf_plus(stderr,
430
 
                     "The total number of considered keys: %d\n",
431
 
                     import_result->considered);
432
 
        fprintf_plus(stderr,
433
 
                     "The number of keys without user ID: %d\n",
434
 
                     import_result->no_user_id);
435
 
        fprintf_plus(stderr,
436
 
                     "The total number of imported keys: %d\n",
437
 
                     import_result->imported);
438
 
        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
439
 
                     import_result->imported_rsa);
440
 
        fprintf_plus(stderr, "The number of unchanged keys: %d\n",
441
 
                     import_result->unchanged);
442
 
        fprintf_plus(stderr, "The number of new user IDs: %d\n",
443
 
                     import_result->new_user_ids);
444
 
        fprintf_plus(stderr, "The number of new sub keys: %d\n",
445
 
                     import_result->new_sub_keys);
446
 
        fprintf_plus(stderr, "The number of new signatures: %d\n",
447
 
                     import_result->new_signatures);
448
 
        fprintf_plus(stderr, "The number of new revocations: %d\n",
449
 
                     import_result->new_revocations);
450
 
        fprintf_plus(stderr,
451
 
                     "The total number of secret keys read: %d\n",
452
 
                     import_result->secret_read);
453
 
        fprintf_plus(stderr,
454
 
                     "The number of imported secret keys: %d\n",
455
 
                     import_result->secret_imported);
456
 
        fprintf_plus(stderr,
457
 
                     "The number of unchanged secret keys: %d\n",
458
 
                     import_result->secret_unchanged);
459
 
        fprintf_plus(stderr, "The number of keys not imported: %d\n",
460
 
                     import_result->not_imported);
461
 
        for(gpgme_import_status_t import_status
462
 
              = import_result->imports;
463
 
            import_status != NULL;
464
 
            import_status = import_status->next){
465
 
          fprintf_plus(stderr, "Import status for key: %s\n",
466
 
                       import_status->fpr);
467
 
          if(import_status->result != GPG_ERR_NO_ERROR){
468
 
            fprintf_plus(stderr, "Import result: %s: %s\n",
469
 
                         gpgme_strsource(import_status->result),
470
 
                         gpgme_strerror(import_status->result));
471
 
          }
472
 
          fprintf_plus(stderr, "Key status:\n");
473
 
          fprintf_plus(stderr,
474
 
                       import_status->status & GPGME_IMPORT_NEW
475
 
                       ? "The key was new.\n"
476
 
                       : "The key was not new.\n");
477
 
          fprintf_plus(stderr,
478
 
                       import_status->status & GPGME_IMPORT_UID
479
 
                       ? "The key contained new user IDs.\n"
480
 
                       : "The key did not contain new user IDs.\n");
481
 
          fprintf_plus(stderr,
482
 
                       import_status->status & GPGME_IMPORT_SIG
483
 
                       ? "The key contained new signatures.\n"
484
 
                       : "The key did not contain new signatures.\n");
485
 
          fprintf_plus(stderr,
486
 
                       import_status->status & GPGME_IMPORT_SUBKEY
487
 
                       ? "The key contained new sub keys.\n"
488
 
                       : "The key did not contain new sub keys.\n");
489
 
          fprintf_plus(stderr,
490
 
                       import_status->status & GPGME_IMPORT_SECRET
491
 
                       ? "The key contained a secret key.\n"
492
 
                       : "The key did not contain a secret key.\n");
493
 
        }
494
 
        return false;
495
 
      }
496
 
    }
497
307
    
498
308
    ret = close(fd);
499
309
    if(ret == -1){
540
350
  /* Create new GPGME "context" */
541
351
  rc = gpgme_new(&(mc->ctx));
542
352
  if(rc != GPG_ERR_NO_ERROR){
543
 
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
544
 
                 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));
545
356
    return false;
546
357
  }
547
358
  
583
394
  /* Create new empty GPGME data buffer for the plaintext */
584
395
  rc = gpgme_data_new(&dh_plain);
585
396
  if(rc != GPG_ERR_NO_ERROR){
586
 
    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",
587
399
                 gpgme_strsource(rc), gpgme_strerror(rc));
588
400
    gpgme_data_release(dh_crypto);
589
401
    return -1;
602
414
      if(result == NULL){
603
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
604
416
      } else {
605
 
        if(result->unsupported_algorithm != NULL) {
606
 
          fprintf_plus(stderr, "Unsupported algorithm: %s\n",
607
 
                       result->unsupported_algorithm);
608
 
        }
609
 
        fprintf_plus(stderr, "Wrong key usage: %s\n",
610
 
                     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);
611
421
        if(result->file_name != NULL){
612
422
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
613
423
        }
614
 
 
615
 
        for(gpgme_recipient_t r = result->recipients; r != NULL;
616
 
            r = r->next){
 
424
        gpgme_recipient_t recipient;
 
425
        recipient = result->recipients;
 
426
        while(recipient != NULL){
617
427
          fprintf_plus(stderr, "Public key algorithm: %s\n",
618
 
                       gpgme_pubkey_algo_name(r->pubkey_algo));
619
 
          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);
620
431
          fprintf_plus(stderr, "Secret key available: %s\n",
621
 
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
 
432
                       recipient->status == GPG_ERR_NO_SECKEY
 
433
                       ? "No" : "Yes");
 
434
          recipient = recipient->next;
622
435
        }
623
436
      }
624
437
    }
700
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
701
514
}
702
515
 
703
 
__attribute__((nonnull(1, 2, 4), warn_unused_result))
 
516
__attribute__((nonnull, warn_unused_result))
704
517
static int init_gnutls_global(const char *pubkeyfilename,
705
518
                              const char *seckeyfilename,
706
519
                              const char *dhparamsfilename,
707
520
                              mandos_context *mc){
708
521
  int ret;
 
522
  unsigned int uret;
709
523
  
710
524
  if(debug){
711
525
    fprintf_plus(stderr, "Initializing GnuTLS\n");
712
526
  }
713
527
  
 
528
  ret = gnutls_global_init();
 
529
  if(ret != GNUTLS_E_SUCCESS){
 
530
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
531
                 safer_gnutls_strerror(ret));
 
532
    return -1;
 
533
  }
 
534
  
714
535
  if(debug){
715
536
    /* "Use a log level over 10 to enable all debugging options."
716
537
     * - GnuTLS manual
724
545
  if(ret != GNUTLS_E_SUCCESS){
725
546
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
726
547
                 safer_gnutls_strerror(ret));
 
548
    gnutls_global_deinit();
727
549
    return -1;
728
550
  }
729
551
  
730
552
  if(debug){
731
 
    fprintf_plus(stderr, "Attempting to use public key %s and"
732
 
                 " private key %s as GnuTLS credentials\n",
 
553
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
554
                 " secret key %s as GnuTLS credentials\n",
733
555
                 pubkeyfilename,
734
556
                 seckeyfilename);
735
557
  }
736
558
  
737
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
738
 
  ret = gnutls_certificate_set_rawpk_key_file
739
 
    (mc->cred, pubkeyfilename, seckeyfilename,
740
 
     GNUTLS_X509_FMT_PEM,       /* format */
741
 
     NULL,                      /* pass */
742
 
     /* key_usage */
743
 
     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
744
 
     NULL,                      /* names */
745
 
     0,                         /* names_length */
746
 
     /* privkey_flags */
747
 
     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
748
 
     0);                        /* pkcs11_flags */
749
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
750
559
  ret = gnutls_certificate_set_openpgp_key_file
751
560
    (mc->cred, pubkeyfilename, seckeyfilename,
752
561
     GNUTLS_OPENPGP_FMT_BASE64);
753
 
#else
754
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
755
 
#endif
756
562
  if(ret != GNUTLS_E_SUCCESS){
757
563
    fprintf_plus(stderr,
758
 
                 "Error[%d] while reading the key pair ('%s',"
 
564
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
759
565
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
760
566
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
761
567
                 safer_gnutls_strerror(ret));
809
615
        }
810
616
        params.size += (unsigned int)bytes_read;
811
617
      }
812
 
      ret = close(dhpfile);
813
 
      if(ret == -1){
814
 
        perror_plus("close");
815
 
      }
816
618
      if(params.data == NULL){
817
619
        dhparamsfilename = NULL;
818
620
      }
827
629
                     safer_gnutls_strerror(ret));
828
630
        dhparamsfilename = NULL;
829
631
      }
830
 
      free(params.data);
831
632
    } while(false);
832
633
  }
833
634
  if(dhparamsfilename == NULL){
834
635
    if(mc->dh_bits == 0){
835
 
#if GNUTLS_VERSION_NUMBER < 0x030600
836
636
      /* Find out the optimal number of DH bits */
837
637
      /* Try to read the private key file */
838
638
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
918
718
          }
919
719
        }
920
720
      }
921
 
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
721
      uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
922
722
      if(uret != 0){
923
723
        mc->dh_bits = uret;
924
724
        if(debug){
936
736
                     safer_gnutls_strerror(ret));
937
737
        goto globalfail;
938
738
      }
939
 
#endif
940
 
    } else {                    /* dh_bits != 0 */
941
 
      if(debug){
942
 
        fprintf_plus(stderr, "DH bits explicitly set to %u\n",
943
 
                     mc->dh_bits);
944
 
      }
945
 
      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
946
 
      if(ret != GNUTLS_E_SUCCESS){
947
 
        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
948
 
                     " bits): %s\n", mc->dh_bits,
949
 
                     safer_gnutls_strerror(ret));
950
 
        goto globalfail;
951
 
      }
952
 
      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
739
    } else if(debug){
 
740
      fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
741
                   mc->dh_bits);
 
742
    }
 
743
    ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
744
    if(ret != GNUTLS_E_SUCCESS){
 
745
      fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
 
746
                   " bits): %s\n", mc->dh_bits,
 
747
                   safer_gnutls_strerror(ret));
 
748
      goto globalfail;
953
749
    }
954
750
  }
 
751
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
955
752
  
956
753
  return 0;
957
754
  
958
755
 globalfail:
959
756
  
960
757
  gnutls_certificate_free_credentials(mc->cred);
 
758
  gnutls_global_deinit();
961
759
  gnutls_dh_params_deinit(mc->dh_params);
962
760
  return -1;
963
761
}
968
766
  int ret;
969
767
  /* GnuTLS session creation */
970
768
  do {
971
 
    ret = gnutls_init(session, (GNUTLS_SERVER
972
 
#if GNUTLS_VERSION_NUMBER >= 0x030506
973
 
                                | GNUTLS_NO_TICKETS
974
 
#endif
975
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
976
 
                                | GNUTLS_ENABLE_RAWPK
977
 
#endif
978
 
                                ));
 
769
    ret = gnutls_init(session, GNUTLS_SERVER);
979
770
    if(quit_now){
980
771
      return -1;
981
772
    }
1029
820
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
1030
821
                      __attribute__((unused)) const char *txt){}
1031
822
 
 
823
/* Set effective uid to 0, return errno */
 
824
__attribute__((warn_unused_result))
 
825
error_t raise_privileges(void){
 
826
  error_t old_errno = errno;
 
827
  error_t ret_errno = 0;
 
828
  if(seteuid(0) == -1){
 
829
    ret_errno = errno;
 
830
  }
 
831
  errno = old_errno;
 
832
  return ret_errno;
 
833
}
 
834
 
 
835
/* Set effective and real user ID to 0.  Return errno. */
 
836
__attribute__((warn_unused_result))
 
837
error_t raise_privileges_permanently(void){
 
838
  error_t old_errno = errno;
 
839
  error_t ret_errno = raise_privileges();
 
840
  if(ret_errno != 0){
 
841
    errno = old_errno;
 
842
    return ret_errno;
 
843
  }
 
844
  if(setuid(0) == -1){
 
845
    ret_errno = errno;
 
846
  }
 
847
  errno = old_errno;
 
848
  return ret_errno;
 
849
}
 
850
 
 
851
/* Set effective user ID to unprivileged saved user ID */
 
852
__attribute__((warn_unused_result))
 
853
error_t lower_privileges(void){
 
854
  error_t old_errno = errno;
 
855
  error_t ret_errno = 0;
 
856
  if(seteuid(uid) == -1){
 
857
    ret_errno = errno;
 
858
  }
 
859
  errno = old_errno;
 
860
  return ret_errno;
 
861
}
 
862
 
 
863
/* Lower privileges permanently */
 
864
__attribute__((warn_unused_result))
 
865
error_t lower_privileges_permanently(void){
 
866
  error_t old_errno = errno;
 
867
  error_t ret_errno = 0;
 
868
  if(setuid(uid) == -1){
 
869
    ret_errno = errno;
 
870
  }
 
871
  errno = old_errno;
 
872
  return ret_errno;
 
873
}
 
874
 
1032
875
/* Helper function to add_local_route() and delete_local_route() */
1033
876
__attribute__((nonnull, warn_unused_result))
1034
877
static bool add_delete_local_route(const bool add,
1073
916
      ret = setgid(0);
1074
917
      if(ret == -1){
1075
918
        perror_plus("setgid");
1076
 
        close(devnull);
1077
919
        _exit(EX_NOPERM);
1078
920
      }
1079
921
      /* Reset supplementary groups */
1081
923
      ret = setgroups(0, NULL);
1082
924
      if(ret == -1){
1083
925
        perror_plus("setgroups");
1084
 
        close(devnull);
1085
926
        _exit(EX_NOPERM);
1086
927
      }
1087
928
    }
1088
929
    ret = dup2(devnull, STDIN_FILENO);
1089
930
    if(ret == -1){
1090
931
      perror_plus("dup2(devnull, STDIN_FILENO)");
1091
 
      close(devnull);
1092
932
      _exit(EX_OSERR);
1093
933
    }
1094
934
    ret = close(devnull);
1095
935
    if(ret == -1){
1096
936
      perror_plus("close");
 
937
      _exit(EX_OSERR);
1097
938
    }
1098
939
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1099
940
    if(ret == -1){
1134
975
  }
1135
976
  if(pid == -1){
1136
977
    perror_plus("fork");
1137
 
    close(devnull);
1138
978
    return false;
1139
979
  }
1140
 
  ret = close(devnull);
1141
 
  if(ret == -1){
1142
 
    perror_plus("close");
1143
 
  }
1144
980
  int status;
1145
981
  pid_t pret = -1;
1146
982
  errno = 0;
1246
1082
    bool match = false;
1247
1083
    {
1248
1084
      char *interface = NULL;
1249
 
      while((interface = argz_next(mc->interfaces,
1250
 
                                   mc->interfaces_size,
1251
 
                                   interface))){
 
1085
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
1086
                                 interface))){
1252
1087
        if(if_nametoindex(interface) == (unsigned int)if_index){
1253
1088
          match = true;
1254
1089
          break;
1388
1223
                    sizeof(struct sockaddr_in));
1389
1224
    }
1390
1225
    if(ret < 0){
1391
 
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
 
1226
      if(errno == ENETUNREACH
1392
1227
         and if_index != AVAHI_IF_UNSPEC
1393
1228
         and connect_to == NULL
1394
1229
         and not route_added and
1407
1242
           with an explicit route added with the server's address.
1408
1243
           
1409
1244
           Avahi bug reference:
1410
 
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1245
           http://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1411
1246
           https://bugs.debian.org/587961
1412
1247
        */
1413
1248
        if(debug){
1593
1428
                                               &decrypted_buffer, mc);
1594
1429
    if(decrypted_buffer_size >= 0){
1595
1430
      
1596
 
      clearerr(stdout);
1597
1431
      written = 0;
1598
1432
      while(written < (size_t) decrypted_buffer_size){
1599
1433
        if(quit_now){
1615
1449
        }
1616
1450
        written += (size_t)ret;
1617
1451
      }
1618
 
      ret = fflush(stdout);
1619
 
      if(ret != 0){
1620
 
        int e = errno;
1621
 
        if(debug){
1622
 
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1623
 
                       strerror(errno));
1624
 
        }
1625
 
        errno = e;
1626
 
        goto mandos_end;
1627
 
      }
1628
1452
      retval = 0;
1629
1453
    }
1630
1454
  }
1661
1485
  return retval;
1662
1486
}
1663
1487
 
 
1488
__attribute__((nonnull))
1664
1489
static void resolve_callback(AvahiSServiceResolver *r,
1665
1490
                             AvahiIfIndex interface,
1666
1491
                             AvahiProtocol proto,
1803
1628
__attribute__((nonnull, warn_unused_result))
1804
1629
bool get_flags(const char *ifname, struct ifreq *ifr){
1805
1630
  int ret;
1806
 
  int old_errno;
 
1631
  error_t ret_errno;
1807
1632
  
1808
1633
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1809
1634
  if(s < 0){
1810
 
    old_errno = errno;
 
1635
    ret_errno = errno;
1811
1636
    perror_plus("socket");
1812
 
    errno = old_errno;
 
1637
    errno = ret_errno;
1813
1638
    return false;
1814
1639
  }
1815
 
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1816
 
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
 
1640
  strcpy(ifr->ifr_name, ifname);
1817
1641
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1818
1642
  if(ret == -1){
1819
1643
    if(debug){
1820
 
      old_errno = errno;
 
1644
      ret_errno = errno;
1821
1645
      perror_plus("ioctl SIOCGIFFLAGS");
1822
 
      errno = old_errno;
1823
 
    }
1824
 
    if((close(s) == -1) and debug){
1825
 
      old_errno = errno;
1826
 
      perror_plus("close");
1827
 
      errno = old_errno;
 
1646
      errno = ret_errno;
1828
1647
    }
1829
1648
    return false;
1830
1649
  }
1831
 
  if((close(s) == -1) and debug){
1832
 
    old_errno = errno;
1833
 
    perror_plus("close");
1834
 
    errno = old_errno;
1835
 
  }
1836
1650
  return true;
1837
1651
}
1838
1652
 
2099
1913
      return;
2100
1914
    }
2101
1915
  }
2102
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2103
 
  if(devnull == -1){
2104
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
2105
 
    return;
2106
 
  }
 
1916
#ifdef __GLIBC__
 
1917
#if __GLIBC_PREREQ(2, 15)
2107
1918
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
2108
1919
                           runnable_hook, alphasort);
 
1920
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1921
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1922
                         alphasort);
 
1923
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1924
#else   /* not __GLIBC__ */
 
1925
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1926
                         alphasort);
 
1927
#endif  /* not __GLIBC__ */
2109
1928
  if(numhooks == -1){
2110
1929
    perror_plus("scandir");
2111
 
    close(devnull);
2112
1930
    return;
2113
1931
  }
2114
1932
  struct dirent *direntry;
2115
1933
  int ret;
 
1934
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
1935
  if(devnull == -1){
 
1936
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
1937
    return;
 
1938
  }
2116
1939
  for(int i = 0; i < numhooks; i++){
2117
1940
    direntry = direntries[i];
2118
1941
    if(debug){
2262
2085
}
2263
2086
 
2264
2087
__attribute__((nonnull, warn_unused_result))
2265
 
int bring_up_interface(const char *const interface,
2266
 
                       const float delay){
2267
 
  int old_errno = errno;
 
2088
error_t bring_up_interface(const char *const interface,
 
2089
                           const float delay){
 
2090
  error_t old_errno = errno;
2268
2091
  int ret;
2269
2092
  struct ifreq network;
2270
2093
  unsigned int if_index = if_nametoindex(interface);
2280
2103
  }
2281
2104
  
2282
2105
  if(not interface_is_up(interface)){
2283
 
    int ret_errno = 0;
2284
 
    int ioctl_errno = 0;
 
2106
    error_t ret_errno = 0, ioctl_errno = 0;
2285
2107
    if(not get_flags(interface, &network)){
2286
2108
      ret_errno = errno;
2287
2109
      fprintf_plus(stderr, "Failed to get flags for interface "
2374
2196
  
2375
2197
  /* Sleep checking until interface is running.
2376
2198
     Check every 0.25s, up to total time of delay */
2377
 
  for(int i = 0; i < delay * 4; i++){
 
2199
  for(int i=0; i < delay * 4; i++){
2378
2200
    if(interface_is_running(interface)){
2379
2201
      break;
2380
2202
    }
2390
2212
}
2391
2213
 
2392
2214
__attribute__((nonnull, warn_unused_result))
2393
 
int take_down_interface(const char *const interface){
2394
 
  int old_errno = errno;
 
2215
error_t take_down_interface(const char *const interface){
 
2216
  error_t old_errno = errno;
2395
2217
  struct ifreq network;
2396
2218
  unsigned int if_index = if_nametoindex(interface);
2397
2219
  if(if_index == 0){
2400
2222
    return ENXIO;
2401
2223
  }
2402
2224
  if(interface_is_up(interface)){
2403
 
    int ret_errno = 0;
2404
 
    int ioctl_errno = 0;
 
2225
    error_t ret_errno = 0, ioctl_errno = 0;
2405
2226
    if(not get_flags(interface, &network) and debug){
2406
2227
      ret_errno = errno;
2407
2228
      fprintf_plus(stderr, "Failed to get flags for interface "
2467
2288
 
2468
2289
int main(int argc, char *argv[]){
2469
2290
  mandos_context mc = { .server = NULL, .dh_bits = 0,
2470
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2471
 
                        .priority = "SECURE128:!CTYPE-X.509"
2472
 
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2473
 
                        ":%PROFILE_ULTRA",
2474
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
2475
2291
                        .priority = "SECURE256:!CTYPE-X.509"
2476
2292
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2477
 
#else
2478
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2479
 
#endif
2480
2293
                        .current_server = NULL, .interfaces = NULL,
2481
2294
                        .interfaces_size = 0 };
2482
2295
  AvahiSServiceBrowser *sb = NULL;
2493
2306
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2494
2307
  const char *seckey = PATHDIR "/" SECKEY;
2495
2308
  const char *pubkey = PATHDIR "/" PUBKEY;
2496
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2497
 
  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2498
 
  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2499
 
#endif
2500
2309
  const char *dh_params_file = NULL;
2501
2310
  char *interfaces_hooks = NULL;
2502
2311
  
2550
2359
      { .name = "pubkey", .key = 'p',
2551
2360
        .arg = "FILE",
2552
2361
        .doc = "OpenPGP public key file base name",
2553
 
        .group = 1 },
2554
 
      { .name = "tls-privkey", .key = 't',
2555
 
        .arg = "FILE",
2556
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2557
 
        .doc = "TLS private key file base name",
2558
 
#else
2559
 
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2560
 
#endif
2561
 
        .group = 1 },
2562
 
      { .name = "tls-pubkey", .key = 'T',
2563
 
        .arg = "FILE",
2564
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2565
 
        .doc = "TLS public key file base name",
2566
 
#else
2567
 
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2568
 
#endif
2569
 
        .group = 1 },
 
2362
        .group = 2 },
2570
2363
      { .name = "dh-bits", .key = 129,
2571
2364
        .arg = "BITS",
2572
2365
        .doc = "Bit length of the prime number used in the"
2628
2421
      case 'p':                 /* --pubkey */
2629
2422
        pubkey = arg;
2630
2423
        break;
2631
 
      case 't':                 /* --tls-privkey */
2632
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2633
 
        tls_privkey = arg;
2634
 
#endif
2635
 
        break;
2636
 
      case 'T':                 /* --tls-pubkey */
2637
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2638
 
        tls_pubkey = arg;
2639
 
#endif
2640
 
        break;
2641
2424
      case 129:                 /* --dh-bits */
2642
2425
        errno = 0;
2643
2426
        tmpmax = strtoimax(arg, &tmp, 10);
2678
2461
        argp_state_help(state, state->out_stream,
2679
2462
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2680
2463
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
2681
 
        __builtin_unreachable();
2682
2464
      case -3:                  /* --usage */
2683
2465
        argp_state_help(state, state->out_stream,
2684
2466
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2685
 
        __builtin_unreachable();
2686
2467
      case 'V':                 /* --version */
2687
2468
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2688
2469
        exit(argp_err_exit_status);
2697
2478
                         .args_doc = "",
2698
2479
                         .doc = "Mandos client -- Get and decrypt"
2699
2480
                         " passwords from a Mandos server" };
2700
 
    ret_errno = argp_parse(&argp, argc, argv,
2701
 
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2702
 
    switch(ret_errno){
 
2481
    ret = argp_parse(&argp, argc, argv,
 
2482
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2483
    switch(ret){
2703
2484
    case 0:
2704
2485
      break;
2705
2486
    case ENOMEM:
2706
2487
    default:
2707
 
      errno = ret_errno;
 
2488
      errno = ret;
2708
2489
      perror_plus("argp_parse");
2709
2490
      exitcode = EX_OSERR;
2710
2491
      goto end;
2716
2497
  
2717
2498
  {
2718
2499
    /* Work around Debian bug #633582:
2719
 
       <https://bugs.debian.org/633582> */
 
2500
       <http://bugs.debian.org/633582> */
2720
2501
    
2721
2502
    /* Re-raise privileges */
2722
 
    ret = raise_privileges();
2723
 
    if(ret != 0){
2724
 
      errno = ret;
 
2503
    ret_errno = raise_privileges();
 
2504
    if(ret_errno != 0){
 
2505
      errno = ret_errno;
2725
2506
      perror_plus("Failed to raise privileges");
2726
2507
    } else {
2727
2508
      struct stat st;
2791
2572
      }
2792
2573
      
2793
2574
      /* Lower privileges */
2794
 
      ret = lower_privileges();
2795
 
      if(ret != 0){
2796
 
        errno = ret;
 
2575
      ret_errno = lower_privileges();
 
2576
      if(ret_errno != 0){
 
2577
        errno = ret_errno;
2797
2578
        perror_plus("Failed to lower privileges");
2798
2579
      }
2799
2580
    }
2999
2780
    goto end;
3000
2781
  }
3001
2782
  
3002
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
3003
 
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
3004
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
3005
2783
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3006
 
#else
3007
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3008
 
#endif
3009
2784
  if(ret == -1){
3010
2785
    fprintf_plus(stderr, "init_gnutls_global failed\n");
3011
2786
    exitcode = EX_UNAVAILABLE;
3133
2908
    
3134
2909
    /* Allocate a new server */
3135
2910
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3136
 
                                 &config, NULL, NULL, &ret);
 
2911
                                 &config, NULL, NULL, &ret_errno);
3137
2912
    
3138
2913
    /* Free the Avahi configuration data */
3139
2914
    avahi_server_config_free(&config);
3142
2917
  /* Check if creating the Avahi server object succeeded */
3143
2918
  if(mc.server == NULL){
3144
2919
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3145
 
                 avahi_strerror(ret));
 
2920
                 avahi_strerror(ret_errno));
3146
2921
    exitcode = EX_UNAVAILABLE;
3147
2922
    goto end;
3148
2923
  }
3183
2958
 end:
3184
2959
  
3185
2960
  if(debug){
3186
 
    if(signal_received){
3187
 
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3188
 
                   argv[0], signal_received,
3189
 
                   strsignal(signal_received));
3190
 
    } else {
3191
 
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
3192
 
    }
 
2961
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
3193
2962
  }
3194
2963
  
3195
2964
  /* Cleanup things */
3206
2975
  
3207
2976
  if(gnutls_initialized){
3208
2977
    gnutls_certificate_free_credentials(mc.cred);
 
2978
    gnutls_global_deinit();
3209
2979
    gnutls_dh_params_deinit(mc.dh_params);
3210
2980
  }
3211
2981
  
3234
3004
  
3235
3005
  /* Re-raise privileges */
3236
3006
  {
3237
 
    ret = raise_privileges();
3238
 
    if(ret != 0){
3239
 
      errno = ret;
 
3007
    ret_errno = raise_privileges();
 
3008
    if(ret_errno != 0){
 
3009
      errno = ret_errno;
3240
3010
      perror_plus("Failed to raise privileges");
3241
3011
    } else {
3242
3012
      
3247
3017
      /* Take down the network interfaces which were brought up */
3248
3018
      {
3249
3019
        char *interface = NULL;
3250
 
        while((interface = argz_next(interfaces_to_take_down,
3251
 
                                     interfaces_to_take_down_size,
3252
 
                                     interface))){
3253
 
          ret = take_down_interface(interface);
3254
 
          if(ret != 0){
3255
 
            errno = ret;
 
3020
        while((interface=argz_next(interfaces_to_take_down,
 
3021
                                   interfaces_to_take_down_size,
 
3022
                                   interface))){
 
3023
          ret_errno = take_down_interface(interface);
 
3024
          if(ret_errno != 0){
 
3025
            errno = ret_errno;
3256
3026
            perror_plus("Failed to take down interface");
3257
3027
          }
3258
3028
        }
3263
3033
      }
3264
3034
    }
3265
3035
    
3266
 
    ret = lower_privileges_permanently();
3267
 
    if(ret != 0){
3268
 
      errno = ret;
 
3036
    ret_errno = lower_privileges_permanently();
 
3037
    if(ret_errno != 0){
 
3038
      errno = ret_errno;
3269
3039
      perror_plus("Failed to lower privileges permanently");
3270
3040
    }
3271
3041
  }
3273
3043
  free(interfaces_to_take_down);
3274
3044
  free(interfaces_hooks);
3275
3045
  
3276
 
  void clean_dir_at(int base, const char * const dirname,
3277
 
                    uintmax_t level){
3278
 
    struct dirent **direntries = NULL;
3279
 
    int dret;
3280
 
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3281
 
                                                O_RDONLY
3282
 
                                                | O_NOFOLLOW
3283
 
                                                | O_DIRECTORY
3284
 
                                                | O_PATH));
3285
 
    if(dir_fd == -1){
3286
 
      perror_plus("open");
3287
 
      return;
3288
 
    }
3289
 
    int numentries = scandirat(dir_fd, ".", &direntries,
3290
 
                               notdotentries, alphasort);
3291
 
    if(numentries >= 0){
3292
 
      for(int i = 0; i < numentries; i++){
3293
 
        if(debug){
3294
 
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3295
 
                       dirname, direntries[i]->d_name);
3296
 
        }
3297
 
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3298
 
        if(dret == -1){
3299
 
          if(errno == EISDIR){
3300
 
              dret = unlinkat(dir_fd, direntries[i]->d_name,
3301
 
                              AT_REMOVEDIR);
3302
 
          }         
3303
 
          if((dret == -1) and (errno == ENOTEMPTY)
3304
 
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3305
 
                  == 0) and (level == 0)){
3306
 
            /* Recurse only in this special case */
3307
 
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3308
 
            dret = 0;
3309
 
          }
3310
 
          if((dret == -1) and (errno != ENOENT)){
3311
 
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3312
 
                         direntries[i]->d_name, strerror(errno));
3313
 
          }
3314
 
        }
3315
 
        free(direntries[i]);
3316
 
      }
3317
 
      
3318
 
      /* need to clean even if 0 because man page doesn't specify */
3319
 
      free(direntries);
3320
 
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
3321
 
      if(dret == -1 and errno != ENOENT){
3322
 
        perror_plus("rmdir");
3323
 
      }
3324
 
    } else {
3325
 
      perror_plus("scandirat");
3326
 
    }
3327
 
    close(dir_fd);
3328
 
  }
3329
 
  
3330
3046
  /* Removes the GPGME temp directory and all files inside */
3331
3047
  if(tempdir != NULL){
3332
 
    clean_dir_at(-1, tempdir, 0);
 
3048
    struct dirent **direntries = NULL;
 
3049
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY
 
3050
                                                  | O_NOFOLLOW
 
3051
                                                  | O_DIRECTORY
 
3052
                                                  | O_PATH));
 
3053
    if(tempdir_fd == -1){
 
3054
      perror_plus("open");
 
3055
    } else {
 
3056
#ifdef __GLIBC__
 
3057
#if __GLIBC_PREREQ(2, 15)
 
3058
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
3059
                                 notdotentries, alphasort);
 
3060
#else  /* not __GLIBC_PREREQ(2, 15) */
 
3061
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
3062
                               alphasort);
 
3063
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
3064
#else   /* not __GLIBC__ */
 
3065
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
3066
                               alphasort);
 
3067
#endif  /* not __GLIBC__ */
 
3068
      if(numentries >= 0){
 
3069
        for(int i = 0; i < numentries; i++){
 
3070
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
3071
          if(ret == -1){
 
3072
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
3073
                         " \"%s\", 0): %s\n", tempdir,
 
3074
                         direntries[i]->d_name, strerror(errno));
 
3075
          }
 
3076
          free(direntries[i]);
 
3077
        }
 
3078
        
 
3079
        /* need to clean even if 0 because man page doesn't specify */
 
3080
        free(direntries);
 
3081
        if(numentries == -1){
 
3082
          perror_plus("scandir");
 
3083
        }
 
3084
        ret = rmdir(tempdir);
 
3085
        if(ret == -1 and errno != ENOENT){
 
3086
          perror_plus("rmdir");
 
3087
        }
 
3088
      }
 
3089
      close(tempdir_fd);
 
3090
    }
3333
3091
  }
3334
3092
  
3335
3093
  if(quit_now){