/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-03-10 18:03:38 UTC
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

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-2011 Teddy Hogeborn
13
 
 * Copyright © 2008-2011 Björn Påhlsson
 
12
 * Copyright © 2008-2014 Teddy Hogeborn
 
13
 * Copyright © 2008-2014 Björn Påhlsson
14
14
 * 
15
15
 * This program is free software: you can redistribute it and/or
16
16
 * modify it under the terms of the GNU General Public License as
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
 
#endif
 
35
#endif  /* not _LARGEFILE_SOURCE */
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
 
#endif
 
38
#endif  /* not _FILE_OFFSET_BITS */
39
39
 
40
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
 
42
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
 
43
                                   stdout, ferror() */
 
44
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
45
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
47
                                   strtof(), abort() */
55
55
                                   opendir(), DIR */
56
56
#include <sys/stat.h>           /* open(), S_ISREG */
57
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
 
58
                                   inet_pton(), connect(),
 
59
                                   getnameinfo() */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
60
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
62
                                 */
62
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
63
64
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
65
#include <errno.h>              /* perror(), errno,
66
66
                                   program_invocation_short_name */
67
67
#include <time.h>               /* nanosleep(), time(), sleep() */
73
73
                                */
74
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
75
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause() */
77
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
76
                                   setgid(), pause(), _exit(),
 
77
                                   unlinkat() */
 
78
#include <arpa/inet.h>          /* inet_pton(), htons() */
78
79
#include <iso646.h>             /* not, or, and */
79
80
#include <argp.h>               /* struct argp_option, error_t, struct
80
81
                                   argp_state, struct argp,
87
88
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
89
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
89
90
                                   WEXITSTATUS(), WTERMSIG() */
 
91
#include <grp.h>                /* setgroups() */
 
92
#include <argz.h>               /* argz_add_sep(), argz_next(),
 
93
                                   argz_delete(), argz_append(),
 
94
                                   argz_stringify(), argz_add(),
 
95
                                   argz_count() */
 
96
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
97
                                   EAI_SYSTEM, gai_strerror() */
90
98
 
91
99
#ifdef __linux__
92
100
#include <sys/klog.h>           /* klogctl() */
134
142
static const char sys_class_net[] = "/sys/class/net";
135
143
char *connect_to = NULL;
136
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
 
146
uid_t uid = 65534;
 
147
gid_t gid = 65534;
137
148
 
138
149
/* Doubly linked list that need to be circularly linked when used */
139
150
typedef struct server{
140
151
  const char *ip;
141
 
  uint16_t port;
 
152
  in_port_t port;
142
153
  AvahiIfIndex if_index;
143
154
  int af;
144
155
  struct timespec last_seen;
148
159
 
149
160
/* Used for passing in values through the Avahi callback functions */
150
161
typedef struct {
151
 
  AvahiSimplePoll *simple_poll;
152
162
  AvahiServer *server;
153
163
  gnutls_certificate_credentials_t cred;
154
164
  unsigned int dh_bits;
156
166
  const char *priority;
157
167
  gpgme_ctx_t ctx;
158
168
  server *current_server;
 
169
  char *interfaces;
 
170
  size_t interfaces_size;
159
171
} mandos_context;
160
172
 
161
 
/* global context so signal handler can reach it*/
162
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
163
 
                      .dh_bits = 1024, .priority = "SECURE256"
164
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
165
 
                      .current_server = NULL };
 
173
/* global so signal handler can reach it*/
 
174
AvahiSimplePoll *simple_poll;
166
175
 
167
176
sig_atomic_t quit_now = 0;
168
177
int signal_received = 0;
169
178
 
170
179
/* Function to use when printing errors */
171
180
void perror_plus(const char *print_text){
 
181
  int e = errno;
172
182
  fprintf(stderr, "Mandos plugin %s: ",
173
183
          program_invocation_short_name);
 
184
  errno = e;
174
185
  perror(print_text);
175
186
}
176
187
 
 
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
177
189
int fprintf_plus(FILE *stream, const char *format, ...){
178
190
  va_list ap;
179
191
  va_start (ap, format);
180
192
  
181
193
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
182
194
                             program_invocation_short_name));
183
 
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
195
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
184
196
}
185
197
 
186
198
/*
188
200
 * bytes. "buffer_capacity" is how much is currently allocated,
189
201
 * "buffer_length" is how much is already used.
190
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
191
204
size_t incbuffer(char **buffer, size_t buffer_length,
192
205
                 size_t buffer_capacity){
193
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
194
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
195
 
    if(buffer == NULL){
 
207
    char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
208
    if(new_buf == NULL){
 
209
      int old_errno = errno;
 
210
      free(*buffer);
 
211
      errno = old_errno;
 
212
      *buffer = NULL;
196
213
      return 0;
197
214
    }
 
215
    *buffer = new_buf;
198
216
    buffer_capacity += BUFFER_SIZE;
199
217
  }
200
218
  return buffer_capacity;
201
219
}
202
220
 
203
221
/* Add server to set of servers to retry periodically */
204
 
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
205
 
               int af){
 
222
__attribute__((nonnull, warn_unused_result))
 
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
224
                int af, server **current_server){
206
225
  int ret;
207
226
  server *new_server = malloc(sizeof(server));
208
227
  if(new_server == NULL){
209
228
    perror_plus("malloc");
210
 
    return -1;
 
229
    return false;
211
230
  }
212
231
  *new_server = (server){ .ip = strdup(ip),
213
232
                          .port = port,
215
234
                          .af = af };
216
235
  if(new_server->ip == NULL){
217
236
    perror_plus("strdup");
218
 
    return -1;
 
237
    free(new_server);
 
238
    return false;
 
239
  }
 
240
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
 
241
  if(ret == -1){
 
242
    perror_plus("clock_gettime");
 
243
#ifdef __GNUC__
 
244
#pragma GCC diagnostic push
 
245
#pragma GCC diagnostic ignored "-Wcast-qual"
 
246
#endif
 
247
    free((char *)(new_server->ip));
 
248
#ifdef __GNUC__
 
249
#pragma GCC diagnostic pop
 
250
#endif
 
251
    free(new_server);
 
252
    return false;
219
253
  }
220
254
  /* Special case of first server */
221
 
  if (mc.current_server == NULL){
 
255
  if(*current_server == NULL){
222
256
    new_server->next = new_server;
223
257
    new_server->prev = new_server;
224
 
    mc.current_server = new_server;
225
 
  /* Place the new server last in the list */
 
258
    *current_server = new_server;
226
259
  } else {
227
 
    new_server->next = mc.current_server;
228
 
    new_server->prev = mc.current_server->prev;
 
260
    /* Place the new server last in the list */
 
261
    new_server->next = *current_server;
 
262
    new_server->prev = (*current_server)->prev;
229
263
    new_server->prev->next = new_server;
230
 
    mc.current_server->prev = new_server;
231
 
  }
232
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
233
 
  if(ret == -1){
234
 
    perror_plus("clock_gettime");
235
 
    return -1;
236
 
  }
237
 
  return 0;
 
264
    (*current_server)->prev = new_server;
 
265
  }
 
266
  return true;
238
267
}
239
268
 
240
269
/* 
241
270
 * Initialize GPGME.
242
271
 */
243
 
static bool init_gpgme(const char *seckey, const char *pubkey,
244
 
                       const char *tempdir){
 
272
__attribute__((nonnull, warn_unused_result))
 
273
static bool init_gpgme(const char * const seckey,
 
274
                       const char * const pubkey,
 
275
                       const char * const tempdir,
 
276
                       mandos_context *mc){
245
277
  gpgme_error_t rc;
246
278
  gpgme_engine_info_t engine_info;
247
279
  
248
 
  
249
280
  /*
250
281
   * Helper function to insert pub and seckey to the engine keyring.
251
282
   */
252
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
253
284
    int ret;
254
285
    int fd;
255
286
    gpgme_data_t pgp_data;
267
298
      return false;
268
299
    }
269
300
    
270
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
301
    rc = gpgme_op_import(mc->ctx, pgp_data);
271
302
    if(rc != GPG_ERR_NO_ERROR){
272
303
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
273
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
317
348
  }
318
349
  
319
350
  /* Create new GPGME "context" */
320
 
  rc = gpgme_new(&(mc.ctx));
 
351
  rc = gpgme_new(&(mc->ctx));
321
352
  if(rc != GPG_ERR_NO_ERROR){
322
353
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
323
354
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
336
367
 * Decrypt OpenPGP data.
337
368
 * Returns -1 on error
338
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
339
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
340
372
                                  size_t crypto_size,
341
 
                                  char **plaintext){
 
373
                                  char **plaintext,
 
374
                                  mandos_context *mc){
342
375
  gpgme_data_t dh_crypto, dh_plain;
343
376
  gpgme_error_t rc;
344
377
  ssize_t ret;
370
403
  
371
404
  /* Decrypt data from the cryptotext data buffer to the plaintext
372
405
     data buffer */
373
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
406
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
374
407
  if(rc != GPG_ERR_NO_ERROR){
375
408
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
376
409
                 gpgme_strsource(rc), gpgme_strerror(rc));
377
410
    plaintext_length = -1;
378
411
    if(debug){
379
412
      gpgme_decrypt_result_t result;
380
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
413
      result = gpgme_op_decrypt_result(mc->ctx);
381
414
      if(result == NULL){
382
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
383
416
      } else {
460
493
  return plaintext_length;
461
494
}
462
495
 
463
 
static const char * safer_gnutls_strerror(int value){
464
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
465
 
                                               -Wunreachable-code */
 
496
__attribute__((warn_unused_result))
 
497
static const char *safer_gnutls_strerror(int value){
 
498
  const char *ret = gnutls_strerror(value);
466
499
  if(ret == NULL)
467
500
    ret = "(unknown)";
468
501
  return ret;
469
502
}
470
503
 
471
504
/* GnuTLS log function callback */
 
505
__attribute__((nonnull))
472
506
static void debuggnutls(__attribute__((unused)) int level,
473
507
                        const char* string){
474
508
  fprintf_plus(stderr, "GnuTLS: %s", string);
475
509
}
476
510
 
 
511
__attribute__((nonnull, warn_unused_result))
477
512
static int init_gnutls_global(const char *pubkeyfilename,
478
 
                              const char *seckeyfilename){
 
513
                              const char *seckeyfilename,
 
514
                              mandos_context *mc){
479
515
  int ret;
480
516
  
481
517
  if(debug){
498
534
  }
499
535
  
500
536
  /* OpenPGP credentials */
501
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
537
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
502
538
  if(ret != GNUTLS_E_SUCCESS){
503
539
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
504
540
                 safer_gnutls_strerror(ret));
514
550
  }
515
551
  
516
552
  ret = gnutls_certificate_set_openpgp_key_file
517
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
553
    (mc->cred, pubkeyfilename, seckeyfilename,
518
554
     GNUTLS_OPENPGP_FMT_BASE64);
519
555
  if(ret != GNUTLS_E_SUCCESS){
520
556
    fprintf_plus(stderr,
526
562
  }
527
563
  
528
564
  /* GnuTLS server initialization */
529
 
  ret = gnutls_dh_params_init(&mc.dh_params);
 
565
  ret = gnutls_dh_params_init(&mc->dh_params);
530
566
  if(ret != GNUTLS_E_SUCCESS){
531
567
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
532
568
                 " initialization: %s\n",
533
569
                 safer_gnutls_strerror(ret));
534
570
    goto globalfail;
535
571
  }
536
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
572
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
537
573
  if(ret != GNUTLS_E_SUCCESS){
538
574
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
539
575
                 safer_gnutls_strerror(ret));
540
576
    goto globalfail;
541
577
  }
542
578
  
543
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
579
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
544
580
  
545
581
  return 0;
546
582
  
547
583
 globalfail:
548
584
  
549
 
  gnutls_certificate_free_credentials(mc.cred);
 
585
  gnutls_certificate_free_credentials(mc->cred);
550
586
  gnutls_global_deinit();
551
 
  gnutls_dh_params_deinit(mc.dh_params);
 
587
  gnutls_dh_params_deinit(mc->dh_params);
552
588
  return -1;
553
589
}
554
590
 
555
 
static int init_gnutls_session(gnutls_session_t *session){
 
591
__attribute__((nonnull, warn_unused_result))
 
592
static int init_gnutls_session(gnutls_session_t *session,
 
593
                               mandos_context *mc){
556
594
  int ret;
557
595
  /* GnuTLS session creation */
558
596
  do {
570
608
  {
571
609
    const char *err;
572
610
    do {
573
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
611
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
574
612
      if(quit_now){
575
613
        gnutls_deinit(*session);
576
614
        return -1;
587
625
  
588
626
  do {
589
627
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
590
 
                                 mc.cred);
 
628
                                 mc->cred);
591
629
    if(quit_now){
592
630
      gnutls_deinit(*session);
593
631
      return -1;
603
641
  /* ignore client certificate if any. */
604
642
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
605
643
  
606
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
644
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
607
645
  
608
646
  return 0;
609
647
}
613
651
                      __attribute__((unused)) const char *txt){}
614
652
 
615
653
/* Called when a Mandos server is found */
616
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
654
__attribute__((nonnull, warn_unused_result))
 
655
static int start_mandos_communication(const char *ip, in_port_t port,
617
656
                                      AvahiIfIndex if_index,
618
 
                                      int af){
 
657
                                      int af, mandos_context *mc){
619
658
  int ret, tcp_sd = -1;
620
659
  ssize_t sret;
621
 
  union {
622
 
    struct sockaddr_in in;
623
 
    struct sockaddr_in6 in6;
624
 
  } to;
 
660
  struct sockaddr_storage to;
625
661
  char *buffer = NULL;
626
662
  char *decrypted_buffer = NULL;
627
663
  size_t buffer_length = 0;
651
687
    return -1;
652
688
  }
653
689
  
654
 
  ret = init_gnutls_session(&session);
 
690
  /* If the interface is specified and we have a list of interfaces */
 
691
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
692
    /* Check if the interface is one of the interfaces we are using */
 
693
    bool match = false;
 
694
    {
 
695
      char *interface = NULL;
 
696
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
697
                                 interface))){
 
698
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
699
          match = true;
 
700
          break;
 
701
        }
 
702
      }
 
703
    }
 
704
    if(not match){
 
705
      /* This interface does not match any in the list, so we don't
 
706
         connect to the server */
 
707
      if(debug){
 
708
        char interface[IF_NAMESIZE];
 
709
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
710
          perror_plus("if_indextoname");
 
711
        } else {
 
712
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
713
                       " \"%s\"\n",
 
714
                       if_indextoname((unsigned int)if_index,
 
715
                                      interface));
 
716
        }
 
717
      }
 
718
      return -1;
 
719
    }
 
720
  }
 
721
  
 
722
  ret = init_gnutls_session(&session, mc);
655
723
  if(ret != 0){
656
724
    return -1;
657
725
  }
658
726
  
659
727
  if(debug){
660
728
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
661
 
                 PRIu16 "\n", ip, port);
 
729
                 PRIuMAX "\n", ip, (uintmax_t)port);
662
730
  }
663
731
  
664
732
  tcp_sd = socket(pf, SOCK_STREAM, 0);
676
744
  
677
745
  memset(&to, 0, sizeof(to));
678
746
  if(af == AF_INET6){
679
 
    to.in6.sin6_family = (sa_family_t)af;
680
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
747
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
 
748
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
681
749
  } else {                      /* IPv4 */
682
 
    to.in.sin_family = (sa_family_t)af;
683
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
750
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
 
751
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
684
752
  }
685
753
  if(ret < 0 ){
686
754
    int e = errno;
695
763
    goto mandos_end;
696
764
  }
697
765
  if(af == AF_INET6){
698
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
699
 
                                       -Wconversion and
700
 
                                       -Wunreachable-code */
701
 
    
702
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
703
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
704
 
                                -Wunreachable-code*/
 
766
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
767
    if(IN6_IS_ADDR_LINKLOCAL
 
768
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
705
769
      if(if_index == AVAHI_IF_UNSPEC){
706
770
        fprintf_plus(stderr, "An IPv6 link-local address is"
707
771
                     " incomplete without a network interface\n");
709
773
        goto mandos_end;
710
774
      }
711
775
      /* Set the network interface number as scope */
712
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
776
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
713
777
    }
714
778
  } else {
715
 
    to.in.sin_port = htons(port); /* Spurious warnings from
716
 
                                     -Wconversion and
717
 
                                     -Wunreachable-code */
 
779
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
718
780
  }
719
781
  
720
782
  if(quit_now){
728
790
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
729
791
        perror_plus("if_indextoname");
730
792
      } else {
731
 
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
732
 
                     "\n", ip, interface, port);
 
793
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
794
                     "\n", ip, interface, (uintmax_t)port);
733
795
      }
734
796
    } else {
735
 
      fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
736
 
                   ip, port);
 
797
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
798
                   ip, (uintmax_t)port);
737
799
    }
738
800
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
739
801
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
740
 
    const char *pcret;
741
802
    if(af == AF_INET6){
742
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
743
 
                        sizeof(addrstr));
 
803
      ret = getnameinfo((struct sockaddr *)&to,
 
804
                        sizeof(struct sockaddr_in6),
 
805
                        addrstr, sizeof(addrstr), NULL, 0,
 
806
                        NI_NUMERICHOST);
744
807
    } else {
745
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
746
 
                        sizeof(addrstr));
 
808
      ret = getnameinfo((struct sockaddr *)&to,
 
809
                        sizeof(struct sockaddr_in),
 
810
                        addrstr, sizeof(addrstr), NULL, 0,
 
811
                        NI_NUMERICHOST);
747
812
    }
748
 
    if(pcret == NULL){
749
 
      perror_plus("inet_ntop");
750
 
    } else {
751
 
      if(strcmp(addrstr, ip) != 0){
752
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
753
 
      }
 
813
    if(ret == EAI_SYSTEM){
 
814
      perror_plus("getnameinfo");
 
815
    } else if(ret != 0) {
 
816
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
817
    } else if(strcmp(addrstr, ip) != 0){
 
818
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
754
819
    }
755
820
  }
756
821
  
760
825
  }
761
826
  
762
827
  if(af == AF_INET6){
763
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
828
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
829
                  sizeof(struct sockaddr_in6));
764
830
  } else {
765
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
831
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
832
                  sizeof(struct sockaddr_in));
766
833
  }
767
834
  if(ret < 0){
768
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
835
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
769
836
      int e = errno;
770
837
      perror_plus("connect");
771
838
      errno = e;
817
884
    goto mandos_end;
818
885
  }
819
886
  
820
 
  /* Spurious warning from -Wint-to-pointer-cast */
821
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
887
  /* This casting via intptr_t is to eliminate warning about casting
 
888
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
889
     function "set-session-transport-fd!" does it. */
 
890
  gnutls_transport_set_ptr(session,
 
891
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
822
892
  
823
893
  if(quit_now){
824
894
    errno = EINTR;
929
999
  if(buffer_length > 0){
930
1000
    ssize_t decrypted_buffer_size;
931
1001
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
932
 
                                               &decrypted_buffer);
 
1002
                                               &decrypted_buffer, mc);
933
1003
    if(decrypted_buffer_size >= 0){
934
1004
      
935
1005
      written = 0;
983
1053
  return retval;
984
1054
}
985
1055
 
 
1056
__attribute__((nonnull))
986
1057
static void resolve_callback(AvahiSServiceResolver *r,
987
1058
                             AvahiIfIndex interface,
988
1059
                             AvahiProtocol proto,
996
1067
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
997
1068
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
998
1069
                             flags,
999
 
                             AVAHI_GCC_UNUSED void* userdata){
1000
 
  assert(r);
 
1070
                             void *mc){
 
1071
  if(r == NULL){
 
1072
    return;
 
1073
  }
1001
1074
  
1002
1075
  /* Called whenever a service has been resolved successfully or
1003
1076
     timed out */
1004
1077
  
1005
1078
  if(quit_now){
 
1079
    avahi_s_service_resolver_free(r);
1006
1080
    return;
1007
1081
  }
1008
1082
  
1012
1086
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1013
1087
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
1014
1088
                 domain,
1015
 
                 avahi_strerror(avahi_server_errno(mc.server)));
 
1089
                 avahi_strerror(avahi_server_errno
 
1090
                                (((mandos_context*)mc)->server)));
1016
1091
    break;
1017
1092
    
1018
1093
  case AVAHI_RESOLVER_FOUND:
1024
1099
                     PRIdMAX ") on port %" PRIu16 "\n", name,
1025
1100
                     host_name, ip, (intmax_t)interface, port);
1026
1101
      }
1027
 
      int ret = start_mandos_communication(ip, port, interface,
1028
 
                                           avahi_proto_to_af(proto));
 
1102
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1103
                                           interface,
 
1104
                                           avahi_proto_to_af(proto),
 
1105
                                           mc);
1029
1106
      if(ret == 0){
1030
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1107
        avahi_simple_poll_quit(simple_poll);
1031
1108
      } else {
1032
 
        ret = add_server(ip, port, interface,
1033
 
                         avahi_proto_to_af(proto));
 
1109
        if(not add_server(ip, (in_port_t)port, interface,
 
1110
                          avahi_proto_to_af(proto),
 
1111
                          &((mandos_context*)mc)->current_server)){
 
1112
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1113
                       " list\n", name);
 
1114
        }
1034
1115
      }
1035
1116
    }
1036
1117
  }
1046
1127
                            const char *domain,
1047
1128
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1048
1129
                            flags,
1049
 
                            AVAHI_GCC_UNUSED void* userdata){
1050
 
  assert(b);
 
1130
                            void *mc){
 
1131
  if(b == NULL){
 
1132
    return;
 
1133
  }
1051
1134
  
1052
1135
  /* Called whenever a new services becomes available on the LAN or
1053
1136
     is removed from the LAN */
1061
1144
  case AVAHI_BROWSER_FAILURE:
1062
1145
    
1063
1146
    fprintf_plus(stderr, "(Avahi browser) %s\n",
1064
 
                 avahi_strerror(avahi_server_errno(mc.server)));
1065
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1147
                 avahi_strerror(avahi_server_errno
 
1148
                                (((mandos_context*)mc)->server)));
 
1149
    avahi_simple_poll_quit(simple_poll);
1066
1150
    return;
1067
1151
    
1068
1152
  case AVAHI_BROWSER_NEW:
1071
1155
       the callback function is called the Avahi server will free the
1072
1156
       resolver for us. */
1073
1157
    
1074
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1075
 
                                    name, type, domain, protocol, 0,
1076
 
                                    resolve_callback, NULL) == NULL)
 
1158
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1159
                                    interface, protocol, name, type,
 
1160
                                    domain, protocol, 0,
 
1161
                                    resolve_callback, mc) == NULL)
1077
1162
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1078
1163
                   " %s\n", name,
1079
 
                   avahi_strerror(avahi_server_errno(mc.server)));
 
1164
                   avahi_strerror(avahi_server_errno
 
1165
                                  (((mandos_context*)mc)->server)));
1080
1166
    break;
1081
1167
    
1082
1168
  case AVAHI_BROWSER_REMOVE:
1101
1187
  signal_received = sig;
1102
1188
  int old_errno = errno;
1103
1189
  /* set main loop to exit */
1104
 
  if(mc.simple_poll != NULL){
1105
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1190
  if(simple_poll != NULL){
 
1191
    avahi_simple_poll_quit(simple_poll);
1106
1192
  }
1107
1193
  errno = old_errno;
1108
1194
}
1109
1195
 
 
1196
__attribute__((nonnull, warn_unused_result))
1110
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1111
1198
  int ret;
 
1199
  error_t ret_errno;
1112
1200
  
1113
1201
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1114
1202
  if(s < 0){
 
1203
    ret_errno = errno;
1115
1204
    perror_plus("socket");
 
1205
    errno = ret_errno;
1116
1206
    return false;
1117
1207
  }
1118
1208
  strcpy(ifr->ifr_name, ifname);
1119
1209
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1120
1210
  if(ret == -1){
1121
1211
    if(debug){
 
1212
      ret_errno = errno;
1122
1213
      perror_plus("ioctl SIOCGIFFLAGS");
 
1214
      errno = ret_errno;
1123
1215
    }
1124
1216
    return false;
1125
1217
  }
1126
1218
  return true;
1127
1219
}
1128
1220
 
 
1221
__attribute__((nonnull, warn_unused_result))
1129
1222
bool good_flags(const char *ifname, const struct ifreq *ifr){
1130
1223
  
1131
1224
  /* Reject the loopback device */
1173
1266
 * corresponds to an acceptable network device.
1174
1267
 * (This function is passed to scandir(3) as a filter function.)
1175
1268
 */
 
1269
__attribute__((nonnull, warn_unused_result))
1176
1270
int good_interface(const struct dirent *if_entry){
1177
1271
  if(if_entry->d_name[0] == '.'){
1178
1272
    return 0;
1194
1288
}
1195
1289
 
1196
1290
/* 
1197
 
 * This function determines if a directory entry in /sys/class/net
1198
 
 * corresponds to an acceptable network device which is up.
1199
 
 * (This function is passed to scandir(3) as a filter function.)
1200
 
 */
1201
 
int up_interface(const struct dirent *if_entry){
1202
 
  if(if_entry->d_name[0] == '.'){
1203
 
    return 0;
1204
 
  }
1205
 
  
1206
 
  struct ifreq ifr;
1207
 
  if(not get_flags(if_entry->d_name, &ifr)){
1208
 
    if(debug){
1209
 
      fprintf_plus(stderr, "Failed to get flags for interface "
1210
 
                   "\"%s\"\n", if_entry->d_name);
1211
 
    }
1212
 
    return 0;
1213
 
  }
1214
 
  
1215
 
  /* Reject down interfaces */
1216
 
  if(not (ifr.ifr_flags & IFF_UP)){
1217
 
    if(debug){
1218
 
      fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1219
 
                   if_entry->d_name);
1220
 
    }
1221
 
    return 0;
1222
 
  }
1223
 
  
1224
 
  /* Reject non-running interfaces */
1225
 
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1226
 
    if(debug){
1227
 
      fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1228
 
                   if_entry->d_name);
1229
 
    }
1230
 
    return 0;
1231
 
  }
1232
 
  
1233
 
  if(not good_flags(if_entry->d_name, &ifr)){
1234
 
    return 0;
1235
 
  }
1236
 
  return 1;
1237
 
}
1238
 
 
 
1291
 * This function determines if a network interface is up.
 
1292
 */
 
1293
__attribute__((nonnull, warn_unused_result))
 
1294
bool interface_is_up(const char *interface){
 
1295
  struct ifreq ifr;
 
1296
  if(not get_flags(interface, &ifr)){
 
1297
    if(debug){
 
1298
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1299
                   "\"%s\"\n", interface);
 
1300
    }
 
1301
    return false;
 
1302
  }
 
1303
  
 
1304
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1305
}
 
1306
 
 
1307
/* 
 
1308
 * This function determines if a network interface is running
 
1309
 */
 
1310
__attribute__((nonnull, warn_unused_result))
 
1311
bool interface_is_running(const char *interface){
 
1312
  struct ifreq ifr;
 
1313
  if(not get_flags(interface, &ifr)){
 
1314
    if(debug){
 
1315
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1316
                   "\"%s\"\n", interface);
 
1317
    }
 
1318
    return false;
 
1319
  }
 
1320
  
 
1321
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1322
}
 
1323
 
 
1324
__attribute__((nonnull, pure, warn_unused_result))
1239
1325
int notdotentries(const struct dirent *direntry){
1240
1326
  /* Skip "." and ".." */
1241
1327
  if(direntry->d_name[0] == '.'
1248
1334
}
1249
1335
 
1250
1336
/* Is this directory entry a runnable program? */
 
1337
__attribute__((nonnull, warn_unused_result))
1251
1338
int runnable_hook(const struct dirent *direntry){
1252
1339
  int ret;
1253
1340
  size_t sret;
1261
1348
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1262
1349
                "abcdefghijklmnopqrstuvwxyz"
1263
1350
                "0123456789"
1264
 
                "_-");
 
1351
                "_.-");
1265
1352
  if((direntry->d_name)[sret] != '\0'){
1266
1353
    /* Contains non-allowed characters */
1267
1354
    if(debug){
1271
1358
    return 0;
1272
1359
  }
1273
1360
  
1274
 
  char *fullname = NULL;
1275
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1276
 
  if(ret < 0){
1277
 
    perror_plus("asprintf");
1278
 
    return 0;
1279
 
  }
1280
 
  
1281
 
  ret = stat(fullname, &st);
 
1361
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1282
1362
  if(ret == -1){
1283
1363
    if(debug){
1284
1364
      perror_plus("Could not stat hook");
1301
1381
    }
1302
1382
    return 0;
1303
1383
  }
 
1384
  if(debug){
 
1385
    fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
 
1386
                 direntry->d_name);
 
1387
  }
1304
1388
  return 1;
1305
1389
}
1306
1390
 
1307
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1391
__attribute__((nonnull, warn_unused_result))
 
1392
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
1393
                            mandos_context *mc){
1308
1394
  int ret;
1309
1395
  struct timespec now;
1310
1396
  struct timespec waited_time;
1311
1397
  intmax_t block_time;
1312
1398
  
1313
1399
  while(true){
1314
 
    if(mc.current_server == NULL){
1315
 
      if (debug){
 
1400
    if(mc->current_server == NULL){
 
1401
      if(debug){
1316
1402
        fprintf_plus(stderr, "Wait until first server is found."
1317
1403
                     " No timeout!\n");
1318
1404
      }
1319
1405
      ret = avahi_simple_poll_iterate(s, -1);
1320
1406
    } else {
1321
 
      if (debug){
 
1407
      if(debug){
1322
1408
        fprintf_plus(stderr, "Check current_server if we should run"
1323
1409
                     " it, or wait\n");
1324
1410
      }
1331
1417
      /* Calculating in ms how long time between now and server
1332
1418
         who we visted longest time ago. Now - last seen.  */
1333
1419
      waited_time.tv_sec = (now.tv_sec
1334
 
                            - mc.current_server->last_seen.tv_sec);
 
1420
                            - mc->current_server->last_seen.tv_sec);
1335
1421
      waited_time.tv_nsec = (now.tv_nsec
1336
 
                             - mc.current_server->last_seen.tv_nsec);
 
1422
                             - mc->current_server->last_seen.tv_nsec);
1337
1423
      /* total time is 10s/10,000ms.
1338
1424
         Converting to s from ms by dividing by 1,000,
1339
1425
         and ns to ms by dividing by 1,000,000. */
1341
1427
                     - ((intmax_t)waited_time.tv_sec * 1000))
1342
1428
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1343
1429
      
1344
 
      if (debug){
 
1430
      if(debug){
1345
1431
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1346
1432
                     block_time);
1347
1433
      }
1348
1434
      
1349
1435
      if(block_time <= 0){
1350
 
        ret = start_mandos_communication(mc.current_server->ip,
1351
 
                                         mc.current_server->port,
1352
 
                                         mc.current_server->if_index,
1353
 
                                         mc.current_server->af);
 
1436
        ret = start_mandos_communication(mc->current_server->ip,
 
1437
                                         mc->current_server->port,
 
1438
                                         mc->current_server->if_index,
 
1439
                                         mc->current_server->af, mc);
1354
1440
        if(ret == 0){
1355
 
          avahi_simple_poll_quit(mc.simple_poll);
 
1441
          avahi_simple_poll_quit(s);
1356
1442
          return 0;
1357
1443
        }
1358
1444
        ret = clock_gettime(CLOCK_MONOTONIC,
1359
 
                            &mc.current_server->last_seen);
 
1445
                            &mc->current_server->last_seen);
1360
1446
        if(ret == -1){
1361
1447
          perror_plus("clock_gettime");
1362
1448
          return -1;
1363
1449
        }
1364
 
        mc.current_server = mc.current_server->next;
 
1450
        mc->current_server = mc->current_server->next;
1365
1451
        block_time = 0;         /* Call avahi to find new Mandos
1366
1452
                                   servers, but don't block */
1367
1453
      }
1369
1455
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1370
1456
    }
1371
1457
    if(ret != 0){
1372
 
      if (ret > 0 or errno != EINTR){
 
1458
      if(ret > 0 or errno != EINTR){
1373
1459
        return (ret != 1) ? ret : 0;
1374
1460
      }
1375
1461
    }
1376
1462
  }
1377
1463
}
1378
1464
 
1379
 
bool run_network_hooks(const char *mode, const char *interface,
 
1465
/* Set effective uid to 0, return errno */
 
1466
__attribute__((warn_unused_result))
 
1467
error_t raise_privileges(void){
 
1468
  error_t old_errno = errno;
 
1469
  error_t ret_errno = 0;
 
1470
  if(seteuid(0) == -1){
 
1471
    ret_errno = errno;
 
1472
  }
 
1473
  errno = old_errno;
 
1474
  return ret_errno;
 
1475
}
 
1476
 
 
1477
/* Set effective and real user ID to 0.  Return errno. */
 
1478
__attribute__((warn_unused_result))
 
1479
error_t raise_privileges_permanently(void){
 
1480
  error_t old_errno = errno;
 
1481
  error_t ret_errno = raise_privileges();
 
1482
  if(ret_errno != 0){
 
1483
    errno = old_errno;
 
1484
    return ret_errno;
 
1485
  }
 
1486
  if(setuid(0) == -1){
 
1487
    ret_errno = errno;
 
1488
  }
 
1489
  errno = old_errno;
 
1490
  return ret_errno;
 
1491
}
 
1492
 
 
1493
/* Set effective user ID to unprivileged saved user ID */
 
1494
__attribute__((warn_unused_result))
 
1495
error_t lower_privileges(void){
 
1496
  error_t old_errno = errno;
 
1497
  error_t ret_errno = 0;
 
1498
  if(seteuid(uid) == -1){
 
1499
    ret_errno = errno;
 
1500
  }
 
1501
  errno = old_errno;
 
1502
  return ret_errno;
 
1503
}
 
1504
 
 
1505
/* Lower privileges permanently */
 
1506
__attribute__((warn_unused_result))
 
1507
error_t lower_privileges_permanently(void){
 
1508
  error_t old_errno = errno;
 
1509
  error_t ret_errno = 0;
 
1510
  if(setuid(uid) == -1){
 
1511
    ret_errno = errno;
 
1512
  }
 
1513
  errno = old_errno;
 
1514
  return ret_errno;
 
1515
}
 
1516
 
 
1517
__attribute__((nonnull))
 
1518
void run_network_hooks(const char *mode, const char *interface,
1380
1519
                       const float delay){
1381
 
  struct dirent **direntries;
1382
 
  struct dirent *direntry;
1383
 
  int ret;
1384
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1385
 
                         alphasort);
 
1520
  struct dirent **direntries = NULL;
 
1521
  if(hookdir_fd == -1){
 
1522
    hookdir_fd = open(hookdir, O_RDONLY);
 
1523
    if(hookdir_fd == -1){
 
1524
      if(errno == ENOENT){
 
1525
        if(debug){
 
1526
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1527
                       " found\n", hookdir);
 
1528
        }
 
1529
      } else {
 
1530
        perror_plus("open");
 
1531
      }
 
1532
      return;
 
1533
    }
 
1534
  }
 
1535
#ifdef __GLIBC__
 
1536
#if __GLIBC_PREREQ(2, 15)
 
1537
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
1538
                           runnable_hook, alphasort);
 
1539
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1540
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1541
                         alphasort);
 
1542
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1543
#else   /* not __GLIBC__ */
 
1544
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1545
                         alphasort);
 
1546
#endif  /* not __GLIBC__ */
1386
1547
  if(numhooks == -1){
1387
1548
    perror_plus("scandir");
1388
 
  } else {
1389
 
    int devnull = open("/dev/null", O_RDONLY);
1390
 
    for(int i = 0; i < numhooks; i++){
1391
 
      direntry = direntries[i];
1392
 
      char *fullname = NULL;
1393
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1394
 
      if(ret < 0){
 
1549
    return;
 
1550
  }
 
1551
  struct dirent *direntry;
 
1552
  int ret;
 
1553
  int devnull = open("/dev/null", O_RDONLY);
 
1554
  for(int i = 0; i < numhooks; i++){
 
1555
    direntry = direntries[i];
 
1556
    if(debug){
 
1557
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1558
                   direntry->d_name);
 
1559
    }
 
1560
    pid_t hook_pid = fork();
 
1561
    if(hook_pid == 0){
 
1562
      /* Child */
 
1563
      /* Raise privileges */
 
1564
      errno = raise_privileges_permanently();
 
1565
      if(errno != 0){
 
1566
        perror_plus("Failed to raise privileges");
 
1567
        _exit(EX_NOPERM);
 
1568
      }
 
1569
      /* Set group */
 
1570
      errno = 0;
 
1571
      ret = setgid(0);
 
1572
      if(ret == -1){
 
1573
        perror_plus("setgid");
 
1574
        _exit(EX_NOPERM);
 
1575
      }
 
1576
      /* Reset supplementary groups */
 
1577
      errno = 0;
 
1578
      ret = setgroups(0, NULL);
 
1579
      if(ret == -1){
 
1580
        perror_plus("setgroups");
 
1581
        _exit(EX_NOPERM);
 
1582
      }
 
1583
      ret = dup2(devnull, STDIN_FILENO);
 
1584
      if(ret == -1){
 
1585
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
1586
        _exit(EX_OSERR);
 
1587
      }
 
1588
      ret = close(devnull);
 
1589
      if(ret == -1){
 
1590
        perror_plus("close");
 
1591
        _exit(EX_OSERR);
 
1592
      }
 
1593
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1594
      if(ret == -1){
 
1595
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1596
        _exit(EX_OSERR);
 
1597
      }
 
1598
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1599
      if(ret == -1){
 
1600
        perror_plus("setenv");
 
1601
        _exit(EX_OSERR);
 
1602
      }
 
1603
      ret = setenv("DEVICE", interface, 1);
 
1604
      if(ret == -1){
 
1605
        perror_plus("setenv");
 
1606
        _exit(EX_OSERR);
 
1607
      }
 
1608
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1609
      if(ret == -1){
 
1610
        perror_plus("setenv");
 
1611
        _exit(EX_OSERR);
 
1612
      }
 
1613
      ret = setenv("MODE", mode, 1);
 
1614
      if(ret == -1){
 
1615
        perror_plus("setenv");
 
1616
        _exit(EX_OSERR);
 
1617
      }
 
1618
      char *delaystring;
 
1619
      ret = asprintf(&delaystring, "%f", (double)delay);
 
1620
      if(ret == -1){
1395
1621
        perror_plus("asprintf");
1396
 
        continue;
1397
 
      }
1398
 
      if(debug){
1399
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1400
 
                     direntry->d_name);
1401
 
      }
1402
 
      pid_t hook_pid = fork();
1403
 
      if(hook_pid == 0){
1404
 
        /* Child */
1405
 
        dup2(devnull, STDIN_FILENO);
1406
 
        close(devnull);
1407
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1408
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1409
 
        if(ret == -1){
1410
 
          perror_plus("setenv");
1411
 
          return false;
1412
 
        }
1413
 
        ret = setenv("DEVICE", interface, 1);
1414
 
        if(ret == -1){
1415
 
          perror_plus("setenv");
1416
 
          return false;
1417
 
        }
1418
 
        ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1419
 
        if(ret == -1){
1420
 
          perror_plus("setenv");
1421
 
          return false;
1422
 
        }
1423
 
        ret = setenv("MODE", mode, 1);
1424
 
        if(ret == -1){
1425
 
          perror_plus("setenv");
1426
 
          return false;
1427
 
        }
1428
 
        char *delaystring;
1429
 
        ret = asprintf(&delaystring, "%f", delay);
1430
 
        if(ret == -1){
1431
 
          perror_plus("asprintf");
1432
 
          return false;
1433
 
        }
1434
 
        ret = setenv("DELAY", delaystring, 1);
1435
 
        if(ret == -1){
1436
 
          free(delaystring);
1437
 
          perror_plus("setenv");
1438
 
          return false;
1439
 
        }
 
1622
        _exit(EX_OSERR);
 
1623
      }
 
1624
      ret = setenv("DELAY", delaystring, 1);
 
1625
      if(ret == -1){
1440
1626
        free(delaystring);
1441
 
        ret = execl(fullname, direntry->d_name, mode, NULL);
1442
 
        perror_plus("execl");
1443
 
      } else {
1444
 
        int status;
1445
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1446
 
          perror_plus("waitpid");
1447
 
          free(fullname);
1448
 
          continue;
1449
 
        }
1450
 
        if(WIFEXITED(status)){
1451
 
          if(WEXITSTATUS(status) != 0){
1452
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1453
 
                         " with status %d\n", direntry->d_name,
1454
 
                         WEXITSTATUS(status));
1455
 
            free(fullname);
1456
 
            continue;
1457
 
          }
1458
 
        } else if(WIFSIGNALED(status)){
1459
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1460
 
                       " signal %d\n", direntry->d_name,
1461
 
                       WTERMSIG(status));
1462
 
          free(fullname);
1463
 
          continue;
1464
 
        } else {
1465
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1466
 
                       " crashed\n", direntry->d_name);
1467
 
          free(fullname);
1468
 
          continue;
1469
 
        }
1470
 
      }
1471
 
      free(fullname);
1472
 
      if(quit_now){
1473
 
        break;
1474
 
      }
1475
 
    }
1476
 
    close(devnull);
1477
 
  }
1478
 
  return true;
 
1627
        perror_plus("setenv");
 
1628
        _exit(EX_OSERR);
 
1629
      }
 
1630
      free(delaystring);
 
1631
      if(connect_to != NULL){
 
1632
        ret = setenv("CONNECT", connect_to, 1);
 
1633
        if(ret == -1){
 
1634
          perror_plus("setenv");
 
1635
          _exit(EX_OSERR);
 
1636
        }
 
1637
      }
 
1638
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
 
1639
      if(hook_fd == -1){
 
1640
        perror_plus("openat");
 
1641
        _exit(EXIT_FAILURE);
 
1642
      }
 
1643
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
1644
        perror_plus("close");
 
1645
        _exit(EXIT_FAILURE);
 
1646
      }
 
1647
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
1648
                 environ) == -1){
 
1649
        perror_plus("fexecve");
 
1650
        _exit(EXIT_FAILURE);
 
1651
      }
 
1652
    } else {
 
1653
      if(hook_pid == -1){
 
1654
        perror_plus("fork");
 
1655
        free(direntry);
 
1656
        continue;
 
1657
      }
 
1658
      int status;
 
1659
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
1660
        perror_plus("waitpid");
 
1661
        free(direntry);
 
1662
        continue;
 
1663
      }
 
1664
      if(WIFEXITED(status)){
 
1665
        if(WEXITSTATUS(status) != 0){
 
1666
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
1667
                       " with status %d\n", direntry->d_name,
 
1668
                       WEXITSTATUS(status));
 
1669
          free(direntry);
 
1670
          continue;
 
1671
        }
 
1672
      } else if(WIFSIGNALED(status)){
 
1673
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
1674
                     " signal %d\n", direntry->d_name,
 
1675
                     WTERMSIG(status));
 
1676
        free(direntry);
 
1677
        continue;
 
1678
      } else {
 
1679
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
1680
                     " crashed\n", direntry->d_name);
 
1681
        free(direntry);
 
1682
        continue;
 
1683
      }
 
1684
    }
 
1685
    if(debug){
 
1686
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
1687
                   direntry->d_name);
 
1688
    }
 
1689
    free(direntry);
 
1690
  }
 
1691
  free(direntries);
 
1692
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
1693
    perror_plus("close");
 
1694
  } else {
 
1695
    hookdir_fd = -1;
 
1696
  }
 
1697
  close(devnull);
 
1698
}
 
1699
 
 
1700
__attribute__((nonnull, warn_unused_result))
 
1701
error_t bring_up_interface(const char *const interface,
 
1702
                           const float delay){
 
1703
  error_t old_errno = errno;
 
1704
  int ret;
 
1705
  struct ifreq network;
 
1706
  unsigned int if_index = if_nametoindex(interface);
 
1707
  if(if_index == 0){
 
1708
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1709
    errno = old_errno;
 
1710
    return ENXIO;
 
1711
  }
 
1712
  
 
1713
  if(quit_now){
 
1714
    errno = old_errno;
 
1715
    return EINTR;
 
1716
  }
 
1717
  
 
1718
  if(not interface_is_up(interface)){
 
1719
    error_t ret_errno = 0, ioctl_errno = 0;
 
1720
    if(not get_flags(interface, &network)){
 
1721
      ret_errno = errno;
 
1722
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1723
                   "\"%s\"\n", interface);
 
1724
      errno = old_errno;
 
1725
      return ret_errno;
 
1726
    }
 
1727
    network.ifr_flags |= IFF_UP; /* set flag */
 
1728
    
 
1729
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1730
    if(sd == -1){
 
1731
      ret_errno = errno;
 
1732
      perror_plus("socket");
 
1733
      errno = old_errno;
 
1734
      return ret_errno;
 
1735
    }
 
1736
    
 
1737
    if(quit_now){
 
1738
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1739
      if(ret == -1){
 
1740
        perror_plus("close");
 
1741
      }
 
1742
      errno = old_errno;
 
1743
      return EINTR;
 
1744
    }
 
1745
    
 
1746
    if(debug){
 
1747
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
1748
                   interface);
 
1749
    }
 
1750
    
 
1751
    /* Raise privileges */
 
1752
    ret_errno = raise_privileges();
 
1753
    if(ret_errno != 0){
 
1754
      errno = ret_errno;
 
1755
      perror_plus("Failed to raise privileges");
 
1756
    }
 
1757
    
 
1758
#ifdef __linux__
 
1759
    int ret_linux;
 
1760
    bool restore_loglevel = false;
 
1761
    if(ret_errno == 0){
 
1762
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1763
         messages about the network interface to mess up the prompt */
 
1764
      ret_linux = klogctl(8, NULL, 5);
 
1765
      if(ret_linux == -1){
 
1766
        perror_plus("klogctl");
 
1767
      } else {
 
1768
        restore_loglevel = true;
 
1769
      }
 
1770
    }
 
1771
#endif  /* __linux__ */
 
1772
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1773
    ioctl_errno = errno;
 
1774
#ifdef __linux__
 
1775
    if(restore_loglevel){
 
1776
      ret_linux = klogctl(7, NULL, 0);
 
1777
      if(ret_linux == -1){
 
1778
        perror_plus("klogctl");
 
1779
      }
 
1780
    }
 
1781
#endif  /* __linux__ */
 
1782
    
 
1783
    /* If raise_privileges() succeeded above */
 
1784
    if(ret_errno == 0){
 
1785
      /* Lower privileges */
 
1786
      ret_errno = lower_privileges();
 
1787
      if(ret_errno != 0){
 
1788
        errno = ret_errno;
 
1789
        perror_plus("Failed to lower privileges");
 
1790
      }
 
1791
    }
 
1792
    
 
1793
    /* Close the socket */
 
1794
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1795
    if(ret == -1){
 
1796
      perror_plus("close");
 
1797
    }
 
1798
    
 
1799
    if(ret_setflags == -1){
 
1800
      errno = ioctl_errno;
 
1801
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
1802
      errno = old_errno;
 
1803
      return ioctl_errno;
 
1804
    }
 
1805
  } else if(debug){
 
1806
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
1807
                 interface);
 
1808
  }
 
1809
  
 
1810
  /* Sleep checking until interface is running.
 
1811
     Check every 0.25s, up to total time of delay */
 
1812
  for(int i=0; i < delay * 4; i++){
 
1813
    if(interface_is_running(interface)){
 
1814
      break;
 
1815
    }
 
1816
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1817
    ret = nanosleep(&sleeptime, NULL);
 
1818
    if(ret == -1 and errno != EINTR){
 
1819
      perror_plus("nanosleep");
 
1820
    }
 
1821
  }
 
1822
  
 
1823
  errno = old_errno;
 
1824
  return 0;
 
1825
}
 
1826
 
 
1827
__attribute__((nonnull, warn_unused_result))
 
1828
error_t take_down_interface(const char *const interface){
 
1829
  error_t old_errno = errno;
 
1830
  struct ifreq network;
 
1831
  unsigned int if_index = if_nametoindex(interface);
 
1832
  if(if_index == 0){
 
1833
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1834
    errno = old_errno;
 
1835
    return ENXIO;
 
1836
  }
 
1837
  if(interface_is_up(interface)){
 
1838
    error_t ret_errno = 0, ioctl_errno = 0;
 
1839
    if(not get_flags(interface, &network) and debug){
 
1840
      ret_errno = errno;
 
1841
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1842
                   "\"%s\"\n", interface);
 
1843
      errno = old_errno;
 
1844
      return ret_errno;
 
1845
    }
 
1846
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1847
    
 
1848
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1849
    if(sd == -1){
 
1850
      ret_errno = errno;
 
1851
      perror_plus("socket");
 
1852
      errno = old_errno;
 
1853
      return ret_errno;
 
1854
    }
 
1855
    
 
1856
    if(debug){
 
1857
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
1858
                   interface);
 
1859
    }
 
1860
    
 
1861
    /* Raise privileges */
 
1862
    ret_errno = raise_privileges();
 
1863
    if(ret_errno != 0){
 
1864
      errno = ret_errno;
 
1865
      perror_plus("Failed to raise privileges");
 
1866
    }
 
1867
    
 
1868
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1869
    ioctl_errno = errno;
 
1870
    
 
1871
    /* If raise_privileges() succeeded above */
 
1872
    if(ret_errno == 0){
 
1873
      /* Lower privileges */
 
1874
      ret_errno = lower_privileges();
 
1875
      if(ret_errno != 0){
 
1876
        errno = ret_errno;
 
1877
        perror_plus("Failed to lower privileges");
 
1878
      }
 
1879
    }
 
1880
    
 
1881
    /* Close the socket */
 
1882
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1883
    if(ret == -1){
 
1884
      perror_plus("close");
 
1885
    }
 
1886
    
 
1887
    if(ret_setflags == -1){
 
1888
      errno = ioctl_errno;
 
1889
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1890
      errno = old_errno;
 
1891
      return ioctl_errno;
 
1892
    }
 
1893
  } else if(debug){
 
1894
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
1895
                 interface);
 
1896
  }
 
1897
  
 
1898
  errno = old_errno;
 
1899
  return 0;
1479
1900
}
1480
1901
 
1481
1902
int main(int argc, char *argv[]){
 
1903
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
 
1904
                        .priority = "SECURE256:!CTYPE-X.509:"
 
1905
                        "+CTYPE-OPENPGP:!RSA", .current_server = NULL,
 
1906
                        .interfaces = NULL, .interfaces_size = 0 };
1482
1907
  AvahiSServiceBrowser *sb = NULL;
1483
 
  int error;
 
1908
  error_t ret_errno;
1484
1909
  int ret;
1485
1910
  intmax_t tmpmax;
1486
1911
  char *tmp;
1487
1912
  int exitcode = EXIT_SUCCESS;
1488
 
  const char *interface = "";
1489
 
  struct ifreq network;
1490
 
  int sd = -1;
1491
 
  bool take_down_interface = false;
1492
 
  uid_t uid;
1493
 
  gid_t gid;
1494
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1495
 
  bool tempdir_created = false;
 
1913
  char *interfaces_to_take_down = NULL;
 
1914
  size_t interfaces_to_take_down_size = 0;
 
1915
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
1916
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
1917
  char *tempdir = NULL;
1496
1918
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1497
1919
  const char *seckey = PATHDIR "/" SECKEY;
1498
1920
  const char *pubkey = PATHDIR "/" PUBKEY;
 
1921
  char *interfaces_hooks = NULL;
1499
1922
  
1500
1923
  bool gnutls_initialized = false;
1501
1924
  bool gpgme_initialized = false;
1563
1986
        .group = 2 },
1564
1987
      { .name = "retry", .key = 132,
1565
1988
        .arg = "SECONDS",
1566
 
        .doc = "Retry interval used when denied by the mandos server",
 
1989
        .doc = "Retry interval used when denied by the Mandos server",
1567
1990
        .group = 2 },
1568
1991
      { .name = "network-hook-dir", .key = 133,
1569
1992
        .arg = "DIR",
1592
2015
        connect_to = arg;
1593
2016
        break;
1594
2017
      case 'i':                 /* --interface */
1595
 
        interface = arg;
 
2018
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2019
                                 arg, (int)',');
 
2020
        if(ret_errno != 0){
 
2021
          argp_error(state, "%s", strerror(ret_errno));
 
2022
        }
1596
2023
        break;
1597
2024
      case 's':                 /* --seckey */
1598
2025
        seckey = arg;
1641
2068
        argp_state_help(state, state->out_stream,
1642
2069
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1643
2070
      case 'V':                 /* --version */
1644
 
        fprintf_plus(state->out_stream,
1645
 
                     "Mandos plugin mandos-client: ");
1646
2071
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1647
2072
        exit(argp_err_exit_status);
1648
2073
        break;
1673
2098
    }
1674
2099
  }
1675
2100
    
1676
 
  if(getuid() == 0){
 
2101
  {
1677
2102
    /* Work around Debian bug #633582:
1678
2103
       <http://bugs.debian.org/633582> */
1679
 
    struct stat st;
1680
 
    
1681
 
    /* Re-raise priviliges */
1682
 
    errno = 0;
1683
 
    ret = seteuid(0);
1684
 
    if(ret == -1){
1685
 
      perror_plus("seteuid");
1686
 
    }
1687
 
    
1688
 
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1689
 
      int seckey_fd = open(seckey, O_RDONLY);
1690
 
      if(seckey_fd == -1){
1691
 
        perror_plus("open");
1692
 
      } else {
1693
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1694
 
        if(ret == -1){
1695
 
          perror_plus("fstat");
1696
 
        } else {
1697
 
          if(S_ISREG(st.st_mode)
1698
 
             and st.st_uid == 0 and st.st_gid == 0){
1699
 
            ret = fchown(seckey_fd, uid, gid);
1700
 
            if(ret == -1){
1701
 
              perror_plus("fchown");
1702
 
            }
1703
 
          }
1704
 
        }
1705
 
        TEMP_FAILURE_RETRY(close(seckey_fd));
1706
 
      }
1707
 
    }
1708
 
    
1709
 
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1710
 
      int pubkey_fd = open(pubkey, O_RDONLY);
1711
 
      if(pubkey_fd == -1){
1712
 
        perror_plus("open");
1713
 
      } else {
1714
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1715
 
        if(ret == -1){
1716
 
          perror_plus("fstat");
1717
 
        } else {
1718
 
          if(S_ISREG(st.st_mode)
1719
 
             and st.st_uid == 0 and st.st_gid == 0){
1720
 
            ret = fchown(pubkey_fd, uid, gid);
1721
 
            if(ret == -1){
1722
 
              perror_plus("fchown");
1723
 
            }
1724
 
          }
1725
 
        }
1726
 
        TEMP_FAILURE_RETRY(close(pubkey_fd));
1727
 
      }
1728
 
    }
1729
 
    
1730
 
    /* Lower privileges */
1731
 
    errno = 0;
1732
 
    ret = seteuid(uid);
1733
 
    if(ret == -1){
1734
 
      perror_plus("seteuid");
 
2104
    
 
2105
    /* Re-raise privileges */
 
2106
    ret_errno = raise_privileges();
 
2107
    if(ret_errno != 0){
 
2108
      errno = ret_errno;
 
2109
      perror_plus("Failed to raise privileges");
 
2110
    } else {
 
2111
      struct stat st;
 
2112
      
 
2113
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
2114
        int seckey_fd = open(seckey, O_RDONLY);
 
2115
        if(seckey_fd == -1){
 
2116
          perror_plus("open");
 
2117
        } else {
 
2118
          ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
2119
          if(ret == -1){
 
2120
            perror_plus("fstat");
 
2121
          } else {
 
2122
            if(S_ISREG(st.st_mode)
 
2123
               and st.st_uid == 0 and st.st_gid == 0){
 
2124
              ret = fchown(seckey_fd, uid, gid);
 
2125
              if(ret == -1){
 
2126
                perror_plus("fchown");
 
2127
              }
 
2128
            }
 
2129
          }
 
2130
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2131
        }
 
2132
      }
 
2133
    
 
2134
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
2135
        int pubkey_fd = open(pubkey, O_RDONLY);
 
2136
        if(pubkey_fd == -1){
 
2137
          perror_plus("open");
 
2138
        } else {
 
2139
          ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
2140
          if(ret == -1){
 
2141
            perror_plus("fstat");
 
2142
          } else {
 
2143
            if(S_ISREG(st.st_mode)
 
2144
               and st.st_uid == 0 and st.st_gid == 0){
 
2145
              ret = fchown(pubkey_fd, uid, gid);
 
2146
              if(ret == -1){
 
2147
                perror_plus("fchown");
 
2148
              }
 
2149
            }
 
2150
          }
 
2151
          TEMP_FAILURE_RETRY(close(pubkey_fd));
 
2152
        }
 
2153
      }
 
2154
    
 
2155
      /* Lower privileges */
 
2156
      ret_errno = lower_privileges();
 
2157
      if(ret_errno != 0){
 
2158
        errno = ret_errno;
 
2159
        perror_plus("Failed to lower privileges");
 
2160
      }
 
2161
    }
 
2162
  }
 
2163
  
 
2164
  /* Remove invalid interface names (except "none") */
 
2165
  {
 
2166
    char *interface = NULL;
 
2167
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2168
                                 interface))){
 
2169
      if(strcmp(interface, "none") != 0
 
2170
         and if_nametoindex(interface) == 0){
 
2171
        if(interface[0] != '\0'){
 
2172
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2173
                       " \"%s\"\n", interface);
 
2174
        }
 
2175
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
 
2176
        interface = NULL;
 
2177
      }
1735
2178
    }
1736
2179
  }
1737
2180
  
1738
2181
  /* Run network hooks */
1739
2182
  {
1740
 
    if(getuid() == 0){
1741
 
      /* Re-raise priviliges */
1742
 
      errno = 0;
1743
 
      ret = seteuid(0);
1744
 
      if(ret == -1){
1745
 
        perror_plus("seteuid");
1746
 
      }
1747
 
    }
1748
 
    if(not run_network_hooks("start", interface, delay)){
1749
 
      goto end;
1750
 
    }
1751
 
    if(getuid() == 0){
1752
 
      /* Lower privileges */
1753
 
      errno = 0;
1754
 
      ret = seteuid(uid);
1755
 
      if(ret == -1){
1756
 
        perror_plus("seteuid");
1757
 
      }
1758
 
    }
 
2183
    if(mc.interfaces != NULL){
 
2184
      interfaces_hooks = malloc(mc.interfaces_size);
 
2185
      if(interfaces_hooks == NULL){
 
2186
        perror_plus("malloc");
 
2187
        goto end;
 
2188
      }
 
2189
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2190
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2191
    }
 
2192
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2193
                      interfaces_hooks : "", delay);
1759
2194
  }
1760
2195
  
1761
2196
  if(not debug){
1762
2197
    avahi_set_log_function(empty_log);
1763
2198
  }
1764
2199
  
1765
 
  if(interface[0] == '\0'){
1766
 
    struct dirent **direntries;
1767
 
    /* First look for interfaces that are up */
1768
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1769
 
                  alphasort);
1770
 
    if(ret == 0){
1771
 
      /* No up interfaces, look for any good interfaces */
1772
 
      free(direntries);
1773
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1774
 
                    alphasort);
1775
 
    }
1776
 
    if(ret >= 1){
1777
 
      /* Pick the first interface returned */
1778
 
      interface = strdup(direntries[0]->d_name);
1779
 
      if(debug){
1780
 
        fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1781
 
      }
1782
 
      if(interface == NULL){
1783
 
        perror_plus("malloc");
1784
 
        free(direntries);
1785
 
        exitcode = EXIT_FAILURE;
1786
 
        goto end;
1787
 
      }
1788
 
      free(direntries);
1789
 
    } else {
1790
 
      free(direntries);
1791
 
      fprintf_plus(stderr, "Could not find a network interface\n");
1792
 
      exitcode = EXIT_FAILURE;
1793
 
      goto end;
1794
 
    }
1795
 
  }
1796
 
  
1797
2200
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1798
2201
     from the signal handler */
1799
2202
  /* Initialize the pseudo-RNG for Avahi */
1800
2203
  srand((unsigned int) time(NULL));
1801
 
  mc.simple_poll = avahi_simple_poll_new();
1802
 
  if(mc.simple_poll == NULL){
 
2204
  simple_poll = avahi_simple_poll_new();
 
2205
  if(simple_poll == NULL){
1803
2206
    fprintf_plus(stderr,
1804
2207
                 "Avahi: Failed to create simple poll object.\n");
1805
2208
    exitcode = EX_UNAVAILABLE;
1869
2272
    }
1870
2273
  }
1871
2274
  
1872
 
  /* If the interface is down, bring it up */
1873
 
  if(strcmp(interface, "none") != 0){
1874
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1875
 
    if(if_index == 0){
1876
 
      fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1877
 
      exitcode = EX_UNAVAILABLE;
1878
 
      goto end;
1879
 
    }
1880
 
    
1881
 
    if(quit_now){
1882
 
      goto end;
1883
 
    }
1884
 
    
1885
 
    /* Re-raise priviliges */
1886
 
    errno = 0;
1887
 
    ret = seteuid(0);
1888
 
    if(ret == -1){
1889
 
      perror_plus("seteuid");
1890
 
    }
1891
 
    
1892
 
#ifdef __linux__
1893
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1894
 
       messages about the network interface to mess up the prompt */
1895
 
    ret = klogctl(8, NULL, 5);
1896
 
    bool restore_loglevel = true;
1897
 
    if(ret == -1){
1898
 
      restore_loglevel = false;
1899
 
      perror_plus("klogctl");
1900
 
    }
1901
 
#endif  /* __linux__ */
1902
 
    
1903
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1904
 
    if(sd < 0){
1905
 
      perror_plus("socket");
1906
 
      exitcode = EX_OSERR;
1907
 
#ifdef __linux__
1908
 
      if(restore_loglevel){
1909
 
        ret = klogctl(7, NULL, 0);
1910
 
        if(ret == -1){
1911
 
          perror_plus("klogctl");
1912
 
        }
1913
 
      }
1914
 
#endif  /* __linux__ */
1915
 
      /* Lower privileges */
1916
 
      errno = 0;
1917
 
      ret = seteuid(uid);
1918
 
      if(ret == -1){
1919
 
        perror_plus("seteuid");
1920
 
      }
1921
 
      goto end;
1922
 
    }
1923
 
    strcpy(network.ifr_name, interface);
1924
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1925
 
    if(ret == -1){
1926
 
      perror_plus("ioctl SIOCGIFFLAGS");
1927
 
#ifdef __linux__
1928
 
      if(restore_loglevel){
1929
 
        ret = klogctl(7, NULL, 0);
1930
 
        if(ret == -1){
1931
 
          perror_plus("klogctl");
1932
 
        }
1933
 
      }
1934
 
#endif  /* __linux__ */
1935
 
      exitcode = EX_OSERR;
1936
 
      /* Lower privileges */
1937
 
      errno = 0;
1938
 
      ret = seteuid(uid);
1939
 
      if(ret == -1){
1940
 
        perror_plus("seteuid");
1941
 
      }
1942
 
      goto end;
1943
 
    }
1944
 
    if((network.ifr_flags & IFF_UP) == 0){
1945
 
      network.ifr_flags |= IFF_UP;
1946
 
      take_down_interface = true;
1947
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1948
 
      if(ret == -1){
1949
 
        take_down_interface = false;
1950
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1951
 
        exitcode = EX_OSERR;
1952
 
#ifdef __linux__
1953
 
        if(restore_loglevel){
1954
 
          ret = klogctl(7, NULL, 0);
1955
 
          if(ret == -1){
1956
 
            perror_plus("klogctl");
 
2275
  /* If no interfaces were specified, make a list */
 
2276
  if(mc.interfaces == NULL){
 
2277
    struct dirent **direntries = NULL;
 
2278
    /* Look for any good interfaces */
 
2279
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2280
                  alphasort);
 
2281
    if(ret >= 1){
 
2282
      /* Add all found interfaces to interfaces list */
 
2283
      for(int i = 0; i < ret; ++i){
 
2284
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2285
                             direntries[i]->d_name);
 
2286
        if(ret_errno != 0){
 
2287
          errno = ret_errno;
 
2288
          perror_plus("argz_add");
 
2289
          free(direntries[i]);
 
2290
          continue;
 
2291
        }
 
2292
        if(debug){
 
2293
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2294
                       direntries[i]->d_name);
 
2295
        }
 
2296
        free(direntries[i]);
 
2297
      }
 
2298
      free(direntries);
 
2299
    } else {
 
2300
      if(ret == 0){
 
2301
        free(direntries);
 
2302
      }
 
2303
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2304
      exitcode = EXIT_FAILURE;
 
2305
      goto end;
 
2306
    }
 
2307
  }
 
2308
  
 
2309
  /* Bring up interfaces which are down, and remove any "none"s */
 
2310
  {
 
2311
    char *interface = NULL;
 
2312
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2313
                                 interface))){
 
2314
      /* If interface name is "none", stop bringing up interfaces.
 
2315
         Also remove all instances of "none" from the list */
 
2316
      if(strcmp(interface, "none") == 0){
 
2317
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2318
                    interface);
 
2319
        interface = NULL;
 
2320
        while((interface = argz_next(mc.interfaces,
 
2321
                                     mc.interfaces_size, interface))){
 
2322
          if(strcmp(interface, "none") == 0){
 
2323
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2324
                        interface);
 
2325
            interface = NULL;
1957
2326
          }
1958
2327
        }
1959
 
#endif  /* __linux__ */
1960
 
        /* Lower privileges */
1961
 
        errno = 0;
1962
 
        ret = seteuid(uid);
1963
 
        if(ret == -1){
1964
 
          perror_plus("seteuid");
1965
 
        }
1966
 
        goto end;
1967
 
      }
1968
 
    }
1969
 
    /* Sleep checking until interface is running.
1970
 
       Check every 0.25s, up to total time of delay */
1971
 
    for(int i=0; i < delay * 4; i++){
1972
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1973
 
      if(ret == -1){
1974
 
        perror_plus("ioctl SIOCGIFFLAGS");
1975
 
      } else if(network.ifr_flags & IFF_RUNNING){
1976
2328
        break;
1977
2329
      }
1978
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1979
 
      ret = nanosleep(&sleeptime, NULL);
1980
 
      if(ret == -1 and errno != EINTR){
1981
 
        perror_plus("nanosleep");
1982
 
      }
1983
 
    }
1984
 
    if(not take_down_interface){
1985
 
      /* We won't need the socket anymore */
1986
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1987
 
      if(ret == -1){
1988
 
        perror_plus("close");
1989
 
      }
1990
 
    }
1991
 
#ifdef __linux__
1992
 
    if(restore_loglevel){
1993
 
      /* Restores kernel loglevel to default */
1994
 
      ret = klogctl(7, NULL, 0);
1995
 
      if(ret == -1){
1996
 
        perror_plus("klogctl");
1997
 
      }
1998
 
    }
1999
 
#endif  /* __linux__ */
2000
 
    /* Lower privileges */
2001
 
    errno = 0;
2002
 
    /* Lower privileges */
2003
 
    ret = seteuid(uid);
2004
 
    if(ret == -1){
2005
 
      perror_plus("seteuid");
2006
 
    }
 
2330
      bool interface_was_up = interface_is_up(interface);
 
2331
      errno = bring_up_interface(interface, delay);
 
2332
      if(not interface_was_up){
 
2333
        if(errno != 0){
 
2334
          perror_plus("Failed to bring up interface");
 
2335
        } else {
 
2336
          errno = argz_add(&interfaces_to_take_down,
 
2337
                           &interfaces_to_take_down_size,
 
2338
                           interface);
 
2339
          if(errno != 0){
 
2340
            perror_plus("argz_add");
 
2341
          }
 
2342
        }
 
2343
      }
 
2344
    }
 
2345
    if(debug and (interfaces_to_take_down == NULL)){
 
2346
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2347
    }
 
2348
  }
 
2349
  
 
2350
  /* If we only got one interface, explicitly use only that one */
 
2351
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2352
    if(debug){
 
2353
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2354
                   mc.interfaces);
 
2355
    }
 
2356
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2007
2357
  }
2008
2358
  
2009
2359
  if(quit_now){
2010
2360
    goto end;
2011
2361
  }
2012
2362
  
2013
 
  ret = init_gnutls_global(pubkey, seckey);
 
2363
  ret = init_gnutls_global(pubkey, seckey, &mc);
2014
2364
  if(ret == -1){
2015
2365
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2016
2366
    exitcode = EX_UNAVAILABLE;
2023
2373
    goto end;
2024
2374
  }
2025
2375
  
2026
 
  if(mkdtemp(tempdir) == NULL){
 
2376
  /* Try /run/tmp before /tmp */
 
2377
  tempdir = mkdtemp(run_tempdir);
 
2378
  if(tempdir == NULL and errno == ENOENT){
 
2379
      if(debug){
 
2380
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
2381
                     run_tempdir, old_tempdir);
 
2382
      }
 
2383
      tempdir = mkdtemp(old_tempdir);
 
2384
  }
 
2385
  if(tempdir == NULL){
2027
2386
    perror_plus("mkdtemp");
2028
2387
    goto end;
2029
2388
  }
2030
 
  tempdir_created = true;
2031
2389
  
2032
2390
  if(quit_now){
2033
2391
    goto end;
2034
2392
  }
2035
2393
  
2036
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
2394
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2037
2395
    fprintf_plus(stderr, "init_gpgme failed\n");
2038
2396
    exitcode = EX_UNAVAILABLE;
2039
2397
    goto end;
2049
2407
    /* Connect directly, do not use Zeroconf */
2050
2408
    /* (Mainly meant for debugging) */
2051
2409
    char *address = strrchr(connect_to, ':');
 
2410
    
2052
2411
    if(address == NULL){
2053
2412
      fprintf_plus(stderr, "No colon in address\n");
2054
2413
      exitcode = EX_USAGE;
2059
2418
      goto end;
2060
2419
    }
2061
2420
    
2062
 
    uint16_t port;
 
2421
    in_port_t port;
2063
2422
    errno = 0;
2064
2423
    tmpmax = strtoimax(address+1, &tmp, 10);
2065
2424
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
2066
 
       or tmpmax != (uint16_t)tmpmax){
 
2425
       or tmpmax != (in_port_t)tmpmax){
2067
2426
      fprintf_plus(stderr, "Bad port number\n");
2068
2427
      exitcode = EX_USAGE;
2069
2428
      goto end;
2070
2429
    }
2071
 
  
 
2430
    
2072
2431
    if(quit_now){
2073
2432
      goto end;
2074
2433
    }
2075
2434
    
2076
 
    port = (uint16_t)tmpmax;
 
2435
    port = (in_port_t)tmpmax;
2077
2436
    *address = '\0';
2078
2437
    /* Colon in address indicates IPv6 */
2079
2438
    int af;
2095
2454
    }
2096
2455
    
2097
2456
    while(not quit_now){
2098
 
      ret = start_mandos_communication(address, port, if_index, af);
 
2457
      ret = start_mandos_communication(address, port, if_index, af,
 
2458
                                       &mc);
2099
2459
      if(quit_now or ret == 0){
2100
2460
        break;
2101
2461
      }
2103
2463
        fprintf_plus(stderr, "Retrying in %d seconds\n",
2104
2464
                     (int)retry_interval);
2105
2465
      }
2106
 
      sleep((int)retry_interval);
 
2466
      sleep((unsigned int)retry_interval);
2107
2467
    }
2108
2468
    
2109
 
    if (not quit_now){
 
2469
    if(not quit_now){
2110
2470
      exitcode = EXIT_SUCCESS;
2111
2471
    }
2112
2472
    
2127
2487
    config.publish_domain = 0;
2128
2488
    
2129
2489
    /* Allocate a new server */
2130
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2131
 
                                 (mc.simple_poll), &config, NULL,
2132
 
                                 NULL, &error);
 
2490
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
2491
                                 &config, NULL, NULL, &ret_errno);
2133
2492
    
2134
2493
    /* Free the Avahi configuration data */
2135
2494
    avahi_server_config_free(&config);
2138
2497
  /* Check if creating the Avahi server object succeeded */
2139
2498
  if(mc.server == NULL){
2140
2499
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2141
 
                 avahi_strerror(error));
 
2500
                 avahi_strerror(ret_errno));
2142
2501
    exitcode = EX_UNAVAILABLE;
2143
2502
    goto end;
2144
2503
  }
2150
2509
  /* Create the Avahi service browser */
2151
2510
  sb = avahi_s_service_browser_new(mc.server, if_index,
2152
2511
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2153
 
                                   NULL, 0, browse_callback, NULL);
 
2512
                                   NULL, 0, browse_callback,
 
2513
                                   (void *)&mc);
2154
2514
  if(sb == NULL){
2155
2515
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
2156
2516
                 avahi_strerror(avahi_server_errno(mc.server)));
2167
2527
  if(debug){
2168
2528
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2169
2529
  }
2170
 
 
2171
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2172
 
                                (int)(retry_interval * 1000));
 
2530
  
 
2531
  ret = avahi_loop_with_timeout(simple_poll,
 
2532
                                (int)(retry_interval * 1000), &mc);
2173
2533
  if(debug){
2174
2534
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2175
2535
                 (ret == 0) ? "successfully" : "with error");
2182
2542
  }
2183
2543
  
2184
2544
  /* Cleanup things */
 
2545
  free(mc.interfaces);
 
2546
  
2185
2547
  if(sb != NULL)
2186
2548
    avahi_s_service_browser_free(sb);
2187
2549
  
2188
2550
  if(mc.server != NULL)
2189
2551
    avahi_server_free(mc.server);
2190
2552
  
2191
 
  if(mc.simple_poll != NULL)
2192
 
    avahi_simple_poll_free(mc.simple_poll);
 
2553
  if(simple_poll != NULL)
 
2554
    avahi_simple_poll_free(simple_poll);
2193
2555
  
2194
2556
  if(gnutls_initialized){
2195
2557
    gnutls_certificate_free_credentials(mc.cred);
2200
2562
  if(gpgme_initialized){
2201
2563
    gpgme_release(mc.ctx);
2202
2564
  }
2203
 
 
 
2565
  
2204
2566
  /* Cleans up the circular linked list of Mandos servers the client
2205
2567
     has seen */
2206
2568
  if(mc.current_server != NULL){
2207
2569
    mc.current_server->prev->next = NULL;
2208
2570
    while(mc.current_server != NULL){
2209
2571
      server *next = mc.current_server->next;
 
2572
#ifdef __GNUC__
 
2573
#pragma GCC diagnostic push
 
2574
#pragma GCC diagnostic ignored "-Wcast-qual"
 
2575
#endif
 
2576
      free((char *)(mc.current_server->ip));
 
2577
#ifdef __GNUC__
 
2578
#pragma GCC diagnostic pop
 
2579
#endif
2210
2580
      free(mc.current_server);
2211
2581
      mc.current_server = next;
2212
2582
    }
2213
2583
  }
2214
2584
  
2215
 
  /* Re-raise priviliges */
 
2585
  /* Re-raise privileges */
2216
2586
  {
2217
 
    if(getuid() == 0){
2218
 
      errno = 0;
2219
 
      ret = seteuid(0);
2220
 
      if(ret == -1){
2221
 
        perror_plus("seteuid");
 
2587
    ret_errno = raise_privileges();
 
2588
    if(ret_errno != 0){
 
2589
      errno = ret_errno;
 
2590
      perror_plus("Failed to raise privileges");
 
2591
    } else {
 
2592
      
 
2593
      /* Run network hooks */
 
2594
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
2595
                        interfaces_hooks : "", delay);
 
2596
      
 
2597
      /* Take down the network interfaces which were brought up */
 
2598
      {
 
2599
        char *interface = NULL;
 
2600
        while((interface=argz_next(interfaces_to_take_down,
 
2601
                                   interfaces_to_take_down_size,
 
2602
                                   interface))){
 
2603
          ret_errno = take_down_interface(interface);
 
2604
          if(ret_errno != 0){
 
2605
            errno = ret_errno;
 
2606
            perror_plus("Failed to take down interface");
 
2607
          }
 
2608
        }
 
2609
        if(debug and (interfaces_to_take_down == NULL)){
 
2610
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
2611
                       " down\n");
 
2612
        }
2222
2613
      }
2223
2614
    }
2224
 
    /* Run network hooks */
2225
 
    if(not run_network_hooks("stop", interface, delay)){
2226
 
      goto end;
2227
 
    }
2228
2615
    
2229
 
    /* Take down the network interface */
2230
 
    if(take_down_interface and geteuid() == 0){
2231
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2232
 
      if(ret == -1){
2233
 
        perror_plus("ioctl SIOCGIFFLAGS");
2234
 
      } else if(network.ifr_flags & IFF_UP){
2235
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2236
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2237
 
        if(ret == -1){
2238
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2239
 
        }
2240
 
      }
2241
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2242
 
      if(ret == -1){
2243
 
        perror_plus("close");
2244
 
      }
2245
 
    }
2246
 
  }
2247
 
  if(getuid() == 0){
2248
 
    /* Lower privileges permanently */
2249
 
    errno = 0;
2250
 
    ret = setuid(uid);
2251
 
    if(ret == -1){
2252
 
      perror_plus("setuid");
2253
 
    }
2254
 
  }
 
2616
    ret_errno = lower_privileges_permanently();
 
2617
    if(ret_errno != 0){
 
2618
      errno = ret_errno;
 
2619
      perror_plus("Failed to lower privileges permanently");
 
2620
    }
 
2621
  }
 
2622
  
 
2623
  free(interfaces_to_take_down);
 
2624
  free(interfaces_hooks);
2255
2625
  
2256
2626
  /* Removes the GPGME temp directory and all files inside */
2257
 
  if(tempdir_created){
 
2627
  if(tempdir != NULL){
2258
2628
    struct dirent **direntries = NULL;
2259
 
    struct dirent *direntry = NULL;
2260
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2261
 
                             alphasort);
2262
 
    if (numentries > 0){
2263
 
      for(int i = 0; i < numentries; i++){
2264
 
        direntry = direntries[i];
2265
 
        char *fullname = NULL;
2266
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2267
 
                       direntry->d_name);
2268
 
        if(ret < 0){
2269
 
          perror_plus("asprintf");
2270
 
          continue;
2271
 
        }
2272
 
        ret = remove(fullname);
2273
 
        if(ret == -1){
2274
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2275
 
                       strerror(errno));
2276
 
        }
2277
 
        free(fullname);
 
2629
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
 
2630
                                                  O_NOFOLLOW));
 
2631
    if(tempdir_fd == -1){
 
2632
      perror_plus("open");
 
2633
    } else {
 
2634
#ifdef __GLIBC__
 
2635
#if __GLIBC_PREREQ(2, 15)
 
2636
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
2637
                                 notdotentries, alphasort);
 
2638
#else  /* not __GLIBC_PREREQ(2, 15) */
 
2639
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2640
                               alphasort);
 
2641
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
2642
#else   /* not __GLIBC__ */
 
2643
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2644
                               alphasort);
 
2645
#endif  /* not __GLIBC__ */
 
2646
      if(numentries >= 0){
 
2647
        for(int i = 0; i < numentries; i++){
 
2648
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
2649
          if(ret == -1){
 
2650
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
2651
                         " \"%s\", 0): %s\n", tempdir,
 
2652
                         direntries[i]->d_name, strerror(errno));
 
2653
          }
 
2654
          free(direntries[i]);
 
2655
        }
 
2656
        
 
2657
        /* need to clean even if 0 because man page doesn't specify */
 
2658
        free(direntries);
 
2659
        if(numentries == -1){
 
2660
          perror_plus("scandir");
 
2661
        }
 
2662
        ret = rmdir(tempdir);
 
2663
        if(ret == -1 and errno != ENOENT){
 
2664
          perror_plus("rmdir");
 
2665
        }
2278
2666
      }
2279
 
    }
2280
 
 
2281
 
    /* need to clean even if 0 because man page doesn't specify */
2282
 
    free(direntries);
2283
 
    if (numentries == -1){
2284
 
      perror_plus("scandir");
2285
 
    }
2286
 
    ret = rmdir(tempdir);
2287
 
    if(ret == -1 and errno != ENOENT){
2288
 
      perror_plus("rmdir");
 
2667
      TEMP_FAILURE_RETRY(close(tempdir_fd));
2289
2668
    }
2290
2669
  }
2291
2670