/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:
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2012 Teddy Hogeborn
13
 
 * Copyright © 2008-2012 Björn Påhlsson
 
12
 * Copyright © 2008-2015 Teddy Hogeborn
 
13
 * Copyright © 2008-2015 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() */
 
43
                                   stdout, ferror() */
44
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() */
48
48
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
 
49
#include <string.h>             /* strcmp(), strlen(), strerror(),
 
50
                                   asprintf(), strcpy() */
51
51
#include <sys/ioctl.h>          /* ioctl */
52
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
53
                                   sockaddr_in6, PF_INET6,
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,
72
73
                                */
73
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
74
75
                                   getuid(), getgid(), seteuid(),
75
 
                                   setgid(), pause(), _exit() */
76
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
76
                                   setgid(), pause(), _exit(),
 
77
                                   unlinkat() */
 
78
#include <arpa/inet.h>          /* inet_pton(), htons() */
77
79
#include <iso646.h>             /* not, or, and */
78
80
#include <argp.h>               /* struct argp_option, error_t, struct
79
81
                                   argp_state, struct argp,
91
93
                                   argz_delete(), argz_append(),
92
94
                                   argz_stringify(), argz_add(),
93
95
                                   argz_count() */
 
96
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
97
                                   EAI_SYSTEM, gai_strerror() */
94
98
 
95
99
#ifdef __linux__
96
100
#include <sys/klog.h>           /* klogctl() */
138
142
static const char sys_class_net[] = "/sys/class/net";
139
143
char *connect_to = NULL;
140
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
141
146
uid_t uid = 65534;
142
147
gid_t gid = 65534;
143
148
 
154
159
 
155
160
/* Used for passing in values through the Avahi callback functions */
156
161
typedef struct {
157
 
  AvahiSimplePoll *simple_poll;
158
162
  AvahiServer *server;
159
163
  gnutls_certificate_credentials_t cred;
160
164
  unsigned int dh_bits;
162
166
  const char *priority;
163
167
  gpgme_ctx_t ctx;
164
168
  server *current_server;
 
169
  char *interfaces;
 
170
  size_t interfaces_size;
165
171
} mandos_context;
166
172
 
167
 
/* global context so signal handler can reach it*/
168
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
169
 
                      .dh_bits = 1024, .priority = "SECURE256"
170
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
171
 
                      .current_server = NULL };
 
173
/* global so signal handler can reach it*/
 
174
AvahiSimplePoll *simple_poll;
172
175
 
173
176
sig_atomic_t quit_now = 0;
174
177
int signal_received = 0;
182
185
  perror(print_text);
183
186
}
184
187
 
185
 
__attribute__((format (gnu_printf, 2, 3)))
 
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
186
189
int fprintf_plus(FILE *stream, const char *format, ...){
187
190
  va_list ap;
188
191
  va_start (ap, format);
189
192
  
190
193
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
191
194
                             program_invocation_short_name));
192
 
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
195
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
193
196
}
194
197
 
195
198
/*
197
200
 * bytes. "buffer_capacity" is how much is currently allocated,
198
201
 * "buffer_length" is how much is already used.
199
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
200
204
size_t incbuffer(char **buffer, size_t buffer_length,
201
205
                 size_t buffer_capacity){
202
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
203
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
204
 
    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;
205
213
      return 0;
206
214
    }
 
215
    *buffer = new_buf;
207
216
    buffer_capacity += BUFFER_SIZE;
208
217
  }
209
218
  return buffer_capacity;
210
219
}
211
220
 
212
221
/* Add server to set of servers to retry periodically */
 
222
__attribute__((nonnull, warn_unused_result))
213
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
214
 
                int af){
 
224
                int af, server **current_server){
215
225
  int ret;
216
226
  server *new_server = malloc(sizeof(server));
217
227
  if(new_server == NULL){
224
234
                          .af = af };
225
235
  if(new_server->ip == NULL){
226
236
    perror_plus("strdup");
 
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);
227
252
    return false;
228
253
  }
229
254
  /* Special case of first server */
230
 
  if (mc.current_server == NULL){
 
255
  if(*current_server == NULL){
231
256
    new_server->next = new_server;
232
257
    new_server->prev = new_server;
233
 
    mc.current_server = new_server;
234
 
  /* Place the new server last in the list */
 
258
    *current_server = new_server;
235
259
  } else {
236
 
    new_server->next = mc.current_server;
237
 
    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;
238
263
    new_server->prev->next = new_server;
239
 
    mc.current_server->prev = new_server;
240
 
  }
241
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
242
 
  if(ret == -1){
243
 
    perror_plus("clock_gettime");
244
 
    return false;
 
264
    (*current_server)->prev = new_server;
245
265
  }
246
266
  return true;
247
267
}
249
269
/* 
250
270
 * Initialize GPGME.
251
271
 */
252
 
static bool init_gpgme(const char *seckey, const char *pubkey,
253
 
                       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){
254
277
  gpgme_error_t rc;
255
278
  gpgme_engine_info_t engine_info;
256
279
  
257
 
  
258
280
  /*
259
281
   * Helper function to insert pub and seckey to the engine keyring.
260
282
   */
261
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
262
284
    int ret;
263
285
    int fd;
264
286
    gpgme_data_t pgp_data;
276
298
      return false;
277
299
    }
278
300
    
279
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
301
    rc = gpgme_op_import(mc->ctx, pgp_data);
280
302
    if(rc != GPG_ERR_NO_ERROR){
281
303
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
282
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
283
305
      return false;
284
306
    }
285
307
    
286
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
308
    ret = close(fd);
287
309
    if(ret == -1){
288
310
      perror_plus("close");
289
311
    }
326
348
  }
327
349
  
328
350
  /* Create new GPGME "context" */
329
 
  rc = gpgme_new(&(mc.ctx));
 
351
  rc = gpgme_new(&(mc->ctx));
330
352
  if(rc != GPG_ERR_NO_ERROR){
331
353
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
332
354
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
345
367
 * Decrypt OpenPGP data.
346
368
 * Returns -1 on error
347
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
348
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
349
372
                                  size_t crypto_size,
350
 
                                  char **plaintext){
 
373
                                  char **plaintext,
 
374
                                  mandos_context *mc){
351
375
  gpgme_data_t dh_crypto, dh_plain;
352
376
  gpgme_error_t rc;
353
377
  ssize_t ret;
379
403
  
380
404
  /* Decrypt data from the cryptotext data buffer to the plaintext
381
405
     data buffer */
382
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
406
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
383
407
  if(rc != GPG_ERR_NO_ERROR){
384
408
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
385
409
                 gpgme_strsource(rc), gpgme_strerror(rc));
386
410
    plaintext_length = -1;
387
411
    if(debug){
388
412
      gpgme_decrypt_result_t result;
389
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
413
      result = gpgme_op_decrypt_result(mc->ctx);
390
414
      if(result == NULL){
391
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
392
416
      } else {
469
493
  return plaintext_length;
470
494
}
471
495
 
472
 
static const char * safer_gnutls_strerror(int value){
 
496
__attribute__((warn_unused_result, const))
 
497
static const char *safe_string(const char *str){
 
498
  if(str == NULL)
 
499
    return "(unknown)";
 
500
  return str;
 
501
}
 
502
 
 
503
__attribute__((warn_unused_result))
 
504
static const char *safer_gnutls_strerror(int value){
473
505
  const char *ret = gnutls_strerror(value);
474
 
  if(ret == NULL)
475
 
    ret = "(unknown)";
476
 
  return ret;
 
506
  return safe_string(ret);
477
507
}
478
508
 
479
509
/* GnuTLS log function callback */
 
510
__attribute__((nonnull))
480
511
static void debuggnutls(__attribute__((unused)) int level,
481
512
                        const char* string){
482
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
483
514
}
484
515
 
 
516
__attribute__((nonnull, warn_unused_result))
485
517
static int init_gnutls_global(const char *pubkeyfilename,
486
 
                              const char *seckeyfilename){
 
518
                              const char *seckeyfilename,
 
519
                              const char *dhparamsfilename,
 
520
                              mandos_context *mc){
487
521
  int ret;
 
522
  unsigned int uret;
488
523
  
489
524
  if(debug){
490
525
    fprintf_plus(stderr, "Initializing GnuTLS\n");
506
541
  }
507
542
  
508
543
  /* OpenPGP credentials */
509
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
544
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
510
545
  if(ret != GNUTLS_E_SUCCESS){
511
546
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
512
547
                 safer_gnutls_strerror(ret));
522
557
  }
523
558
  
524
559
  ret = gnutls_certificate_set_openpgp_key_file
525
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
560
    (mc->cred, pubkeyfilename, seckeyfilename,
526
561
     GNUTLS_OPENPGP_FMT_BASE64);
527
562
  if(ret != GNUTLS_E_SUCCESS){
528
563
    fprintf_plus(stderr,
534
569
  }
535
570
  
536
571
  /* GnuTLS server initialization */
537
 
  ret = gnutls_dh_params_init(&mc.dh_params);
 
572
  ret = gnutls_dh_params_init(&mc->dh_params);
538
573
  if(ret != GNUTLS_E_SUCCESS){
539
574
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
540
575
                 " initialization: %s\n",
541
576
                 safer_gnutls_strerror(ret));
542
577
    goto globalfail;
543
578
  }
544
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
545
 
  if(ret != GNUTLS_E_SUCCESS){
546
 
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
547
 
                 safer_gnutls_strerror(ret));
548
 
    goto globalfail;
549
 
  }
550
 
  
551
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
579
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
580
  if(dhparamsfilename != NULL){
 
581
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
582
    do {
 
583
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
584
      if(dhpfile == -1){
 
585
        perror_plus("open");
 
586
        dhparamsfilename = NULL;
 
587
        break;
 
588
      }
 
589
      size_t params_capacity = 0;
 
590
      while(true){
 
591
        params_capacity = incbuffer((char **)&params.data,
 
592
                                    (size_t)params.size,
 
593
                                    (size_t)params_capacity);
 
594
        if(params_capacity == 0){
 
595
          perror_plus("incbuffer");
 
596
          free(params.data);
 
597
          params.data = NULL;
 
598
          dhparamsfilename = NULL;
 
599
          break;
 
600
        }
 
601
        ssize_t bytes_read = read(dhpfile,
 
602
                                  params.data + params.size,
 
603
                                  BUFFER_SIZE);
 
604
        /* EOF */
 
605
        if(bytes_read == 0){
 
606
          break;
 
607
        }
 
608
        /* check bytes_read for failure */
 
609
        if(bytes_read < 0){
 
610
          perror_plus("read");
 
611
          free(params.data);
 
612
          params.data = NULL;
 
613
          dhparamsfilename = NULL;
 
614
          break;
 
615
        }
 
616
        params.size += (unsigned int)bytes_read;
 
617
      }
 
618
      if(params.data == NULL){
 
619
        dhparamsfilename = NULL;
 
620
      }
 
621
      if(dhparamsfilename == NULL){
 
622
        break;
 
623
      }
 
624
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
 
625
                                          GNUTLS_X509_FMT_PEM);
 
626
      if(ret != GNUTLS_E_SUCCESS){
 
627
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
 
628
                     " \"%s\": %s\n", dhparamsfilename,
 
629
                     safer_gnutls_strerror(ret));
 
630
        dhparamsfilename = NULL;
 
631
      }
 
632
    } while(false);
 
633
  }
 
634
  if(dhparamsfilename == NULL){
 
635
    if(mc->dh_bits == 0){
 
636
      /* Find out the optimal number of DH bits */
 
637
      /* Try to read the private key file */
 
638
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
639
      do {
 
640
        int secfile = open(seckeyfilename, O_RDONLY);
 
641
        if(secfile == -1){
 
642
          perror_plus("open");
 
643
          break;
 
644
        }
 
645
        size_t buffer_capacity = 0;
 
646
        while(true){
 
647
          buffer_capacity = incbuffer((char **)&buffer.data,
 
648
                                      (size_t)buffer.size,
 
649
                                      (size_t)buffer_capacity);
 
650
          if(buffer_capacity == 0){
 
651
            perror_plus("incbuffer");
 
652
            free(buffer.data);
 
653
            buffer.data = NULL;
 
654
            break;
 
655
          }
 
656
          ssize_t bytes_read = read(secfile,
 
657
                                    buffer.data + buffer.size,
 
658
                                    BUFFER_SIZE);
 
659
          /* EOF */
 
660
          if(bytes_read == 0){
 
661
            break;
 
662
          }
 
663
          /* check bytes_read for failure */
 
664
          if(bytes_read < 0){
 
665
            perror_plus("read");
 
666
            free(buffer.data);
 
667
            buffer.data = NULL;
 
668
            break;
 
669
          }
 
670
          buffer.size += (unsigned int)bytes_read;
 
671
        }
 
672
        close(secfile);
 
673
      } while(false);
 
674
      /* If successful, use buffer to parse private key */
 
675
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
676
      if(buffer.data != NULL){
 
677
        {
 
678
          gnutls_openpgp_privkey_t privkey = NULL;
 
679
          ret = gnutls_openpgp_privkey_init(&privkey);
 
680
          if(ret != GNUTLS_E_SUCCESS){
 
681
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
682
                         " structure: %s",
 
683
                         safer_gnutls_strerror(ret));
 
684
            free(buffer.data);
 
685
            buffer.data = NULL;
 
686
          } else {
 
687
            ret = gnutls_openpgp_privkey_import
 
688
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
 
689
            if(ret != GNUTLS_E_SUCCESS){
 
690
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
691
                           safer_gnutls_strerror(ret));
 
692
              privkey = NULL;
 
693
            }
 
694
            free(buffer.data);
 
695
            buffer.data = NULL;
 
696
            if(privkey != NULL){
 
697
              /* Use private key to suggest an appropriate
 
698
                 sec_param */
 
699
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
700
              gnutls_openpgp_privkey_deinit(privkey);
 
701
              if(debug){
 
702
                fprintf_plus(stderr, "This OpenPGP key implies using"
 
703
                             " a GnuTLS security parameter \"%s\".\n",
 
704
                             safe_string(gnutls_sec_param_get_name
 
705
                                         (sec_param)));
 
706
              }
 
707
            }
 
708
          }
 
709
        }
 
710
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
711
          /* Err on the side of caution */
 
712
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
713
          if(debug){
 
714
            fprintf_plus(stderr, "Falling back to security parameter"
 
715
                         " \"%s\"\n",
 
716
                         safe_string(gnutls_sec_param_get_name
 
717
                                     (sec_param)));
 
718
          }
 
719
        }
 
720
      }
 
721
      uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
722
      if(uret != 0){
 
723
        mc->dh_bits = uret;
 
724
        if(debug){
 
725
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
726
                       " implies %u DH bits; using that.\n",
 
727
                       safe_string(gnutls_sec_param_get_name
 
728
                                   (sec_param)),
 
729
                       mc->dh_bits);
 
730
        }
 
731
      } else {
 
732
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
733
                     " bits for security parameter \"%s\"): %s\n",
 
734
                     safe_string(gnutls_sec_param_get_name
 
735
                                 (sec_param)),
 
736
                     safer_gnutls_strerror(ret));
 
737
        goto globalfail;
 
738
      }
 
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;
 
749
    }
 
750
  }
 
751
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
552
752
  
553
753
  return 0;
554
754
  
555
755
 globalfail:
556
756
  
557
 
  gnutls_certificate_free_credentials(mc.cred);
 
757
  gnutls_certificate_free_credentials(mc->cred);
558
758
  gnutls_global_deinit();
559
 
  gnutls_dh_params_deinit(mc.dh_params);
 
759
  gnutls_dh_params_deinit(mc->dh_params);
560
760
  return -1;
561
761
}
562
762
 
563
 
static int init_gnutls_session(gnutls_session_t *session){
 
763
__attribute__((nonnull, warn_unused_result))
 
764
static int init_gnutls_session(gnutls_session_t *session,
 
765
                               mandos_context *mc){
564
766
  int ret;
565
767
  /* GnuTLS session creation */
566
768
  do {
578
780
  {
579
781
    const char *err;
580
782
    do {
581
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
783
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
582
784
      if(quit_now){
583
785
        gnutls_deinit(*session);
584
786
        return -1;
595
797
  
596
798
  do {
597
799
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
598
 
                                 mc.cred);
 
800
                                 mc->cred);
599
801
    if(quit_now){
600
802
      gnutls_deinit(*session);
601
803
      return -1;
611
813
  /* ignore client certificate if any. */
612
814
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
613
815
  
614
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
615
 
  
616
816
  return 0;
617
817
}
618
818
 
620
820
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
621
821
                      __attribute__((unused)) const char *txt){}
622
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
 
 
875
/* Helper function to add_local_route() and delete_local_route() */
 
876
__attribute__((nonnull, warn_unused_result))
 
877
static bool add_delete_local_route(const bool add,
 
878
                                   const char *address,
 
879
                                   AvahiIfIndex if_index){
 
880
  int ret;
 
881
  char helper[] = "mandos-client-iprouteadddel";
 
882
  char add_arg[] = "add";
 
883
  char delete_arg[] = "delete";
 
884
  char debug_flag[] = "--debug";
 
885
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
 
886
  if(pluginhelperdir == NULL){
 
887
    if(debug){
 
888
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
 
889
                   " variable not set; cannot run helper\n");
 
890
    }
 
891
    return false;
 
892
  }
 
893
  
 
894
  char interface[IF_NAMESIZE];
 
895
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
896
    perror_plus("if_indextoname");
 
897
    return false;
 
898
  }
 
899
  
 
900
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
901
  if(devnull == -1){
 
902
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
903
    return false;
 
904
  }
 
905
  pid_t pid = fork();
 
906
  if(pid == 0){
 
907
    /* Child */
 
908
    /* Raise privileges */
 
909
    errno = raise_privileges_permanently();
 
910
    if(errno != 0){
 
911
      perror_plus("Failed to raise privileges");
 
912
      /* _exit(EX_NOPERM); */
 
913
    } else {
 
914
      /* Set group */
 
915
      errno = 0;
 
916
      ret = setgid(0);
 
917
      if(ret == -1){
 
918
        perror_plus("setgid");
 
919
        _exit(EX_NOPERM);
 
920
      }
 
921
      /* Reset supplementary groups */
 
922
      errno = 0;
 
923
      ret = setgroups(0, NULL);
 
924
      if(ret == -1){
 
925
        perror_plus("setgroups");
 
926
        _exit(EX_NOPERM);
 
927
      }
 
928
    }
 
929
    ret = dup2(devnull, STDIN_FILENO);
 
930
    if(ret == -1){
 
931
      perror_plus("dup2(devnull, STDIN_FILENO)");
 
932
      _exit(EX_OSERR);
 
933
    }
 
934
    ret = close(devnull);
 
935
    if(ret == -1){
 
936
      perror_plus("close");
 
937
      _exit(EX_OSERR);
 
938
    }
 
939
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
940
    if(ret == -1){
 
941
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
942
      _exit(EX_OSERR);
 
943
    }
 
944
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
 
945
                                                    O_RDONLY
 
946
                                                    | O_DIRECTORY
 
947
                                                    | O_PATH
 
948
                                                    | O_CLOEXEC));
 
949
    if(helperdir_fd == -1){
 
950
      perror_plus("open");
 
951
      _exit(EX_UNAVAILABLE);
 
952
    }
 
953
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
 
954
                                                   helper, O_RDONLY));
 
955
    if(helper_fd == -1){
 
956
      perror_plus("openat");
 
957
      close(helperdir_fd);
 
958
      _exit(EX_UNAVAILABLE);
 
959
    }
 
960
    close(helperdir_fd);
 
961
#ifdef __GNUC__
 
962
#pragma GCC diagnostic push
 
963
#pragma GCC diagnostic ignored "-Wcast-qual"
 
964
#endif
 
965
    if(fexecve(helper_fd, (char *const [])
 
966
               { helper, add ? add_arg : delete_arg, (char *)address,
 
967
                   interface, debug ? debug_flag : NULL, NULL },
 
968
               environ) == -1){
 
969
#ifdef __GNUC__
 
970
#pragma GCC diagnostic pop
 
971
#endif
 
972
      perror_plus("fexecve");
 
973
      _exit(EXIT_FAILURE);
 
974
    }
 
975
  }
 
976
  if(pid == -1){
 
977
    perror_plus("fork");
 
978
    return false;
 
979
  }
 
980
  int status;
 
981
  pid_t pret = -1;
 
982
  errno = 0;
 
983
  do {
 
984
    pret = waitpid(pid, &status, 0);
 
985
    if(pret == -1 and errno == EINTR and quit_now){
 
986
      int errno_raising = 0;
 
987
      if((errno = raise_privileges()) != 0){
 
988
        errno_raising = errno;
 
989
        perror_plus("Failed to raise privileges in order to"
 
990
                    " kill helper program");
 
991
      }
 
992
      if(kill(pid, SIGTERM) == -1){
 
993
        perror_plus("kill");
 
994
      }
 
995
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
 
996
        perror_plus("Failed to lower privileges after killing"
 
997
                    " helper program");
 
998
      }
 
999
      return false;
 
1000
    }
 
1001
  } while(pret == -1 and errno == EINTR);
 
1002
  if(pret == -1){
 
1003
    perror_plus("waitpid");
 
1004
    return false;
 
1005
  }
 
1006
  if(WIFEXITED(status)){
 
1007
    if(WEXITSTATUS(status) != 0){
 
1008
      fprintf_plus(stderr, "Error: iprouteadddel exited"
 
1009
                   " with status %d\n", WEXITSTATUS(status));
 
1010
      return false;
 
1011
    }
 
1012
    return true;
 
1013
  }
 
1014
  if(WIFSIGNALED(status)){
 
1015
    fprintf_plus(stderr, "Error: iprouteadddel died by"
 
1016
                 " signal %d\n", WTERMSIG(status));
 
1017
    return false;
 
1018
  }
 
1019
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
 
1020
  return false;
 
1021
}
 
1022
 
 
1023
__attribute__((nonnull, warn_unused_result))
 
1024
static bool add_local_route(const char *address,
 
1025
                            AvahiIfIndex if_index){
 
1026
  if(debug){
 
1027
    fprintf_plus(stderr, "Adding route to %s\n", address);
 
1028
  }
 
1029
  return add_delete_local_route(true, address, if_index);
 
1030
}
 
1031
 
 
1032
__attribute__((nonnull, warn_unused_result))
 
1033
static bool delete_local_route(const char *address,
 
1034
                               AvahiIfIndex if_index){
 
1035
  if(debug){
 
1036
    fprintf_plus(stderr, "Removing route to %s\n", address);
 
1037
  }
 
1038
  return add_delete_local_route(false, address, if_index);
 
1039
}
 
1040
 
623
1041
/* Called when a Mandos server is found */
 
1042
__attribute__((nonnull, warn_unused_result))
624
1043
static int start_mandos_communication(const char *ip, in_port_t port,
625
1044
                                      AvahiIfIndex if_index,
626
 
                                      int af){
 
1045
                                      int af, mandos_context *mc){
627
1046
  int ret, tcp_sd = -1;
628
1047
  ssize_t sret;
629
 
  union {
630
 
    struct sockaddr_in in;
631
 
    struct sockaddr_in6 in6;
632
 
  } to;
 
1048
  struct sockaddr_storage to;
633
1049
  char *buffer = NULL;
634
1050
  char *decrypted_buffer = NULL;
635
1051
  size_t buffer_length = 0;
638
1054
  int retval = -1;
639
1055
  gnutls_session_t session;
640
1056
  int pf;                       /* Protocol family */
 
1057
  bool route_added = false;
641
1058
  
642
1059
  errno = 0;
643
1060
  
659
1076
    return -1;
660
1077
  }
661
1078
  
662
 
  ret = init_gnutls_session(&session);
 
1079
  /* If the interface is specified and we have a list of interfaces */
 
1080
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
1081
    /* Check if the interface is one of the interfaces we are using */
 
1082
    bool match = false;
 
1083
    {
 
1084
      char *interface = NULL;
 
1085
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
1086
                                 interface))){
 
1087
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
1088
          match = true;
 
1089
          break;
 
1090
        }
 
1091
      }
 
1092
    }
 
1093
    if(not match){
 
1094
      /* This interface does not match any in the list, so we don't
 
1095
         connect to the server */
 
1096
      if(debug){
 
1097
        char interface[IF_NAMESIZE];
 
1098
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1099
          perror_plus("if_indextoname");
 
1100
        } else {
 
1101
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
1102
                       " \"%s\"\n",
 
1103
                       if_indextoname((unsigned int)if_index,
 
1104
                                      interface));
 
1105
        }
 
1106
      }
 
1107
      return -1;
 
1108
    }
 
1109
  }
 
1110
  
 
1111
  ret = init_gnutls_session(&session, mc);
663
1112
  if(ret != 0){
664
1113
    return -1;
665
1114
  }
669
1118
                 PRIuMAX "\n", ip, (uintmax_t)port);
670
1119
  }
671
1120
  
672
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1121
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
673
1122
  if(tcp_sd < 0){
674
1123
    int e = errno;
675
1124
    perror_plus("socket");
682
1131
    goto mandos_end;
683
1132
  }
684
1133
  
685
 
  memset(&to, 0, sizeof(to));
686
1134
  if(af == AF_INET6){
687
 
    to.in6.sin6_family = (sa_family_t)af;
688
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
1135
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1136
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1137
    ret = inet_pton(af, ip, &to6->sin6_addr);
689
1138
  } else {                      /* IPv4 */
690
 
    to.in.sin_family = (sa_family_t)af;
691
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
1139
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1140
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1141
    ret = inet_pton(af, ip, &to4->sin_addr);
692
1142
  }
693
1143
  if(ret < 0 ){
694
1144
    int e = errno;
703
1153
    goto mandos_end;
704
1154
  }
705
1155
  if(af == AF_INET6){
706
 
    to.in6.sin6_port = htons(port);    
707
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
708
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
709
 
                                -Wunreachable-code*/
 
1156
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
1157
    if(IN6_IS_ADDR_LINKLOCAL
 
1158
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
710
1159
      if(if_index == AVAHI_IF_UNSPEC){
711
1160
        fprintf_plus(stderr, "An IPv6 link-local address is"
712
1161
                     " incomplete without a network interface\n");
714
1163
        goto mandos_end;
715
1164
      }
716
1165
      /* Set the network interface number as scope */
717
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
1166
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
718
1167
    }
719
1168
  } else {
720
 
    to.in.sin_port = htons(port); /* Spurious warnings from
721
 
                                     -Wconversion and
722
 
                                     -Wunreachable-code */
 
1169
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
723
1170
  }
724
1171
  
725
1172
  if(quit_now){
742
1189
    }
743
1190
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
744
1191
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
745
 
    const char *pcret;
746
 
    if(af == AF_INET6){
747
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
748
 
                        sizeof(addrstr));
749
 
    } else {
750
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
751
 
                        sizeof(addrstr));
752
 
    }
753
 
    if(pcret == NULL){
754
 
      perror_plus("inet_ntop");
755
 
    } else {
756
 
      if(strcmp(addrstr, ip) != 0){
757
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
758
 
      }
759
 
    }
760
 
  }
761
 
  
762
 
  if(quit_now){
763
 
    errno = EINTR;
764
 
    goto mandos_end;
765
 
  }
766
 
  
767
 
  if(af == AF_INET6){
768
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
769
 
  } else {
770
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
771
 
  }
772
 
  if(ret < 0){
773
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
774
 
      int e = errno;
775
 
      perror_plus("connect");
776
 
      errno = e;
777
 
    }
778
 
    goto mandos_end;
779
 
  }
780
 
  
781
 
  if(quit_now){
782
 
    errno = EINTR;
783
 
    goto mandos_end;
 
1192
    if(af == AF_INET6){
 
1193
      ret = getnameinfo((struct sockaddr *)&to,
 
1194
                        sizeof(struct sockaddr_in6),
 
1195
                        addrstr, sizeof(addrstr), NULL, 0,
 
1196
                        NI_NUMERICHOST);
 
1197
    } else {
 
1198
      ret = getnameinfo((struct sockaddr *)&to,
 
1199
                        sizeof(struct sockaddr_in),
 
1200
                        addrstr, sizeof(addrstr), NULL, 0,
 
1201
                        NI_NUMERICHOST);
 
1202
    }
 
1203
    if(ret == EAI_SYSTEM){
 
1204
      perror_plus("getnameinfo");
 
1205
    } else if(ret != 0) {
 
1206
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
1207
    } else if(strcmp(addrstr, ip) != 0){
 
1208
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
 
1209
    }
 
1210
  }
 
1211
  
 
1212
  if(quit_now){
 
1213
    errno = EINTR;
 
1214
    goto mandos_end;
 
1215
  }
 
1216
  
 
1217
  while(true){
 
1218
    if(af == AF_INET6){
 
1219
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1220
                    sizeof(struct sockaddr_in6));
 
1221
    } else {
 
1222
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1223
                    sizeof(struct sockaddr_in));
 
1224
    }
 
1225
    if(ret < 0){
 
1226
      if(errno == ENETUNREACH
 
1227
         and if_index != AVAHI_IF_UNSPEC
 
1228
         and connect_to == NULL
 
1229
         and not route_added and
 
1230
         ((af == AF_INET6 and not
 
1231
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1232
                                    &to)->sin6_addr)))
 
1233
          or (af == AF_INET and
 
1234
              /* Not a a IPv4LL address */
 
1235
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1236
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1237
        /* Work around Avahi bug - Avahi does not announce link-local
 
1238
           addresses if it has a global address, so local hosts with
 
1239
           *only* a link-local address (e.g. Mandos clients) cannot
 
1240
           connect to a Mandos server announced by Avahi on a server
 
1241
           host with a global address.  Work around this by retrying
 
1242
           with an explicit route added with the server's address.
 
1243
           
 
1244
           Avahi bug reference:
 
1245
           http://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1246
           https://bugs.debian.org/587961
 
1247
        */
 
1248
        if(debug){
 
1249
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1250
                       " direct route\n");
 
1251
        }
 
1252
        int e = errno;
 
1253
        route_added = add_local_route(ip, if_index);
 
1254
        if(route_added){
 
1255
          continue;
 
1256
        }
 
1257
        errno = e;
 
1258
      }
 
1259
      if(errno != ECONNREFUSED or debug){
 
1260
        int e = errno;
 
1261
        perror_plus("connect");
 
1262
        errno = e;
 
1263
      }
 
1264
      goto mandos_end;
 
1265
    }
 
1266
    
 
1267
    if(quit_now){
 
1268
      errno = EINTR;
 
1269
      goto mandos_end;
 
1270
    }
 
1271
    break;
784
1272
  }
785
1273
  
786
1274
  const char *out = mandos_protocol_version;
937
1425
  if(buffer_length > 0){
938
1426
    ssize_t decrypted_buffer_size;
939
1427
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
940
 
                                               &decrypted_buffer);
 
1428
                                               &decrypted_buffer, mc);
941
1429
    if(decrypted_buffer_size >= 0){
942
1430
      
943
1431
      written = 0;
969
1457
  
970
1458
 mandos_end:
971
1459
  {
 
1460
    if(route_added){
 
1461
      if(not delete_local_route(ip, if_index)){
 
1462
        fprintf_plus(stderr, "Failed to delete local route to %s on"
 
1463
                     " interface %d", ip, if_index);
 
1464
      }
 
1465
    }
972
1466
    int e = errno;
973
1467
    free(decrypted_buffer);
974
1468
    free(buffer);
975
1469
    if(tcp_sd >= 0){
976
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1470
      ret = close(tcp_sd);
977
1471
    }
978
1472
    if(ret == -1){
979
1473
      if(e == 0){
991
1485
  return retval;
992
1486
}
993
1487
 
 
1488
__attribute__((nonnull))
994
1489
static void resolve_callback(AvahiSServiceResolver *r,
995
1490
                             AvahiIfIndex interface,
996
1491
                             AvahiProtocol proto,
1004
1499
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
1005
1500
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
1006
1501
                             flags,
1007
 
                             AVAHI_GCC_UNUSED void* userdata){
 
1502
                             void *mc){
1008
1503
  if(r == NULL){
1009
1504
    return;
1010
1505
  }
1013
1508
     timed out */
1014
1509
  
1015
1510
  if(quit_now){
 
1511
    avahi_s_service_resolver_free(r);
1016
1512
    return;
1017
1513
  }
1018
1514
  
1022
1518
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1023
1519
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
1024
1520
                 domain,
1025
 
                 avahi_strerror(avahi_server_errno(mc.server)));
 
1521
                 avahi_strerror(avahi_server_errno
 
1522
                                (((mandos_context*)mc)->server)));
1026
1523
    break;
1027
1524
    
1028
1525
  case AVAHI_RESOLVER_FOUND:
1036
1533
      }
1037
1534
      int ret = start_mandos_communication(ip, (in_port_t)port,
1038
1535
                                           interface,
1039
 
                                           avahi_proto_to_af(proto));
 
1536
                                           avahi_proto_to_af(proto),
 
1537
                                           mc);
1040
1538
      if(ret == 0){
1041
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1539
        avahi_simple_poll_quit(simple_poll);
1042
1540
      } else {
1043
1541
        if(not add_server(ip, (in_port_t)port, interface,
1044
 
                          avahi_proto_to_af(proto))){
 
1542
                          avahi_proto_to_af(proto),
 
1543
                          &((mandos_context*)mc)->current_server)){
1045
1544
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1046
1545
                       " list\n", name);
1047
1546
        }
1060
1559
                            const char *domain,
1061
1560
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1062
1561
                            flags,
1063
 
                            AVAHI_GCC_UNUSED void* userdata){
 
1562
                            void *mc){
1064
1563
  if(b == NULL){
1065
1564
    return;
1066
1565
  }
1077
1576
  case AVAHI_BROWSER_FAILURE:
1078
1577
    
1079
1578
    fprintf_plus(stderr, "(Avahi browser) %s\n",
1080
 
                 avahi_strerror(avahi_server_errno(mc.server)));
1081
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1579
                 avahi_strerror(avahi_server_errno
 
1580
                                (((mandos_context*)mc)->server)));
 
1581
    avahi_simple_poll_quit(simple_poll);
1082
1582
    return;
1083
1583
    
1084
1584
  case AVAHI_BROWSER_NEW:
1087
1587
       the callback function is called the Avahi server will free the
1088
1588
       resolver for us. */
1089
1589
    
1090
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1091
 
                                    name, type, domain, protocol, 0,
1092
 
                                    resolve_callback, NULL) == NULL)
 
1590
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1591
                                    interface, protocol, name, type,
 
1592
                                    domain, protocol, 0,
 
1593
                                    resolve_callback, mc) == NULL)
1093
1594
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1094
1595
                   " %s\n", name,
1095
 
                   avahi_strerror(avahi_server_errno(mc.server)));
 
1596
                   avahi_strerror(avahi_server_errno
 
1597
                                  (((mandos_context*)mc)->server)));
1096
1598
    break;
1097
1599
    
1098
1600
  case AVAHI_BROWSER_REMOVE:
1117
1619
  signal_received = sig;
1118
1620
  int old_errno = errno;
1119
1621
  /* set main loop to exit */
1120
 
  if(mc.simple_poll != NULL){
1121
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1622
  if(simple_poll != NULL){
 
1623
    avahi_simple_poll_quit(simple_poll);
1122
1624
  }
1123
1625
  errno = old_errno;
1124
1626
}
1125
1627
 
 
1628
__attribute__((nonnull, warn_unused_result))
1126
1629
bool get_flags(const char *ifname, struct ifreq *ifr){
1127
1630
  int ret;
1128
1631
  error_t ret_errno;
1147
1650
  return true;
1148
1651
}
1149
1652
 
 
1653
__attribute__((nonnull, warn_unused_result))
1150
1654
bool good_flags(const char *ifname, const struct ifreq *ifr){
1151
1655
  
1152
1656
  /* Reject the loopback device */
1194
1698
 * corresponds to an acceptable network device.
1195
1699
 * (This function is passed to scandir(3) as a filter function.)
1196
1700
 */
 
1701
__attribute__((nonnull, warn_unused_result))
1197
1702
int good_interface(const struct dirent *if_entry){
1198
1703
  if(if_entry->d_name[0] == '.'){
1199
1704
    return 0;
1217
1722
/* 
1218
1723
 * This function determines if a network interface is up.
1219
1724
 */
 
1725
__attribute__((nonnull, warn_unused_result))
1220
1726
bool interface_is_up(const char *interface){
1221
1727
  struct ifreq ifr;
1222
1728
  if(not get_flags(interface, &ifr)){
1233
1739
/* 
1234
1740
 * This function determines if a network interface is running
1235
1741
 */
 
1742
__attribute__((nonnull, warn_unused_result))
1236
1743
bool interface_is_running(const char *interface){
1237
1744
  struct ifreq ifr;
1238
1745
  if(not get_flags(interface, &ifr)){
1246
1753
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
1247
1754
}
1248
1755
 
 
1756
__attribute__((nonnull, pure, warn_unused_result))
1249
1757
int notdotentries(const struct dirent *direntry){
1250
1758
  /* Skip "." and ".." */
1251
1759
  if(direntry->d_name[0] == '.'
1258
1766
}
1259
1767
 
1260
1768
/* Is this directory entry a runnable program? */
 
1769
__attribute__((nonnull, warn_unused_result))
1261
1770
int runnable_hook(const struct dirent *direntry){
1262
1771
  int ret;
1263
1772
  size_t sret;
1271
1780
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1272
1781
                "abcdefghijklmnopqrstuvwxyz"
1273
1782
                "0123456789"
1274
 
                "_-");
 
1783
                "_.-");
1275
1784
  if((direntry->d_name)[sret] != '\0'){
1276
1785
    /* Contains non-allowed characters */
1277
1786
    if(debug){
1281
1790
    return 0;
1282
1791
  }
1283
1792
  
1284
 
  char *fullname = NULL;
1285
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1286
 
  if(ret < 0){
1287
 
    perror_plus("asprintf");
1288
 
    return 0;
1289
 
  }
1290
 
  
1291
 
  ret = stat(fullname, &st);
 
1793
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1292
1794
  if(ret == -1){
1293
1795
    if(debug){
1294
1796
      perror_plus("Could not stat hook");
1318
1820
  return 1;
1319
1821
}
1320
1822
 
1321
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1823
__attribute__((nonnull, warn_unused_result))
 
1824
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
1825
                            mandos_context *mc){
1322
1826
  int ret;
1323
1827
  struct timespec now;
1324
1828
  struct timespec waited_time;
1325
1829
  intmax_t block_time;
1326
1830
  
1327
1831
  while(true){
1328
 
    if(mc.current_server == NULL){
1329
 
      if (debug){
 
1832
    if(mc->current_server == NULL){
 
1833
      if(debug){
1330
1834
        fprintf_plus(stderr, "Wait until first server is found."
1331
1835
                     " No timeout!\n");
1332
1836
      }
1333
1837
      ret = avahi_simple_poll_iterate(s, -1);
1334
1838
    } else {
1335
 
      if (debug){
 
1839
      if(debug){
1336
1840
        fprintf_plus(stderr, "Check current_server if we should run"
1337
1841
                     " it, or wait\n");
1338
1842
      }
1345
1849
      /* Calculating in ms how long time between now and server
1346
1850
         who we visted longest time ago. Now - last seen.  */
1347
1851
      waited_time.tv_sec = (now.tv_sec
1348
 
                            - mc.current_server->last_seen.tv_sec);
 
1852
                            - mc->current_server->last_seen.tv_sec);
1349
1853
      waited_time.tv_nsec = (now.tv_nsec
1350
 
                             - mc.current_server->last_seen.tv_nsec);
 
1854
                             - mc->current_server->last_seen.tv_nsec);
1351
1855
      /* total time is 10s/10,000ms.
1352
1856
         Converting to s from ms by dividing by 1,000,
1353
1857
         and ns to ms by dividing by 1,000,000. */
1355
1859
                     - ((intmax_t)waited_time.tv_sec * 1000))
1356
1860
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1357
1861
      
1358
 
      if (debug){
 
1862
      if(debug){
1359
1863
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1360
1864
                     block_time);
1361
1865
      }
1362
1866
      
1363
1867
      if(block_time <= 0){
1364
 
        ret = start_mandos_communication(mc.current_server->ip,
1365
 
                                         mc.current_server->port,
1366
 
                                         mc.current_server->if_index,
1367
 
                                         mc.current_server->af);
 
1868
        ret = start_mandos_communication(mc->current_server->ip,
 
1869
                                         mc->current_server->port,
 
1870
                                         mc->current_server->if_index,
 
1871
                                         mc->current_server->af, mc);
1368
1872
        if(ret == 0){
1369
 
          avahi_simple_poll_quit(mc.simple_poll);
 
1873
          avahi_simple_poll_quit(s);
1370
1874
          return 0;
1371
1875
        }
1372
1876
        ret = clock_gettime(CLOCK_MONOTONIC,
1373
 
                            &mc.current_server->last_seen);
 
1877
                            &mc->current_server->last_seen);
1374
1878
        if(ret == -1){
1375
1879
          perror_plus("clock_gettime");
1376
1880
          return -1;
1377
1881
        }
1378
 
        mc.current_server = mc.current_server->next;
 
1882
        mc->current_server = mc->current_server->next;
1379
1883
        block_time = 0;         /* Call avahi to find new Mandos
1380
1884
                                   servers, but don't block */
1381
1885
      }
1383
1887
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1384
1888
    }
1385
1889
    if(ret != 0){
1386
 
      if (ret > 0 or errno != EINTR){
 
1890
      if(ret > 0 or errno != EINTR){
1387
1891
        return (ret != 1) ? ret : 0;
1388
1892
      }
1389
1893
    }
1390
1894
  }
1391
1895
}
1392
1896
 
1393
 
/* Set effective uid to 0, return errno */
1394
 
error_t raise_privileges(void){
1395
 
  error_t old_errno = errno;
1396
 
  error_t ret_errno = 0;
1397
 
  if(seteuid(0) == -1){
1398
 
    ret_errno = errno;
1399
 
    perror_plus("seteuid");
1400
 
  }
1401
 
  errno = old_errno;
1402
 
  return ret_errno;
1403
 
}
1404
 
 
1405
 
/* Set effective and real user ID to 0.  Return errno. */
1406
 
error_t raise_privileges_permanently(void){
1407
 
  error_t old_errno = errno;
1408
 
  error_t ret_errno = raise_privileges();
1409
 
  if(ret_errno != 0){
1410
 
    errno = old_errno;
1411
 
    return ret_errno;
1412
 
  }
1413
 
  if(setuid(0) == -1){
1414
 
    ret_errno = errno;
1415
 
    perror_plus("seteuid");
1416
 
  }
1417
 
  errno = old_errno;
1418
 
  return ret_errno;
1419
 
}
1420
 
 
1421
 
/* Set effective user ID to unprivileged saved user ID */
1422
 
error_t lower_privileges(void){
1423
 
  error_t old_errno = errno;
1424
 
  error_t ret_errno = 0;
1425
 
  if(seteuid(uid) == -1){
1426
 
    ret_errno = errno;
1427
 
    perror_plus("seteuid");
1428
 
  }
1429
 
  errno = old_errno;
1430
 
  return ret_errno;
1431
 
}
1432
 
 
1433
 
/* Lower privileges permanently */
1434
 
error_t lower_privileges_permanently(void){
1435
 
  error_t old_errno = errno;
1436
 
  error_t ret_errno = 0;
1437
 
  if(setuid(uid) == -1){
1438
 
    ret_errno = errno;
1439
 
    perror_plus("setuid");
1440
 
  }
1441
 
  errno = old_errno;
1442
 
  return ret_errno;
1443
 
}
1444
 
 
1445
 
bool run_network_hooks(const char *mode, const char *interface,
 
1897
__attribute__((nonnull))
 
1898
void run_network_hooks(const char *mode, const char *interface,
1446
1899
                       const float delay){
1447
 
  struct dirent **direntries;
 
1900
  struct dirent **direntries = NULL;
 
1901
  if(hookdir_fd == -1){
 
1902
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
1903
                      | O_CLOEXEC);
 
1904
    if(hookdir_fd == -1){
 
1905
      if(errno == ENOENT){
 
1906
        if(debug){
 
1907
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1908
                       " found\n", hookdir);
 
1909
        }
 
1910
      } else {
 
1911
        perror_plus("open");
 
1912
      }
 
1913
      return;
 
1914
    }
 
1915
  }
 
1916
#ifdef __GLIBC__
 
1917
#if __GLIBC_PREREQ(2, 15)
 
1918
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
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__ */
 
1928
  if(numhooks == -1){
 
1929
    perror_plus("scandir");
 
1930
    return;
 
1931
  }
1448
1932
  struct dirent *direntry;
1449
1933
  int ret;
1450
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1451
 
                         alphasort);
1452
 
  if(numhooks == -1){
1453
 
    if(errno == ENOENT){
1454
 
      if(debug){
1455
 
        fprintf_plus(stderr, "Network hook directory \"%s\" not"
1456
 
                     " found\n", hookdir);
1457
 
      }
1458
 
    } else {
1459
 
      perror_plus("scandir");
 
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
  }
 
1939
  for(int i = 0; i < numhooks; i++){
 
1940
    direntry = direntries[i];
 
1941
    if(debug){
 
1942
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1943
                   direntry->d_name);
1460
1944
    }
1461
 
  } else {
1462
 
    int devnull = open("/dev/null", O_RDONLY);
1463
 
    for(int i = 0; i < numhooks; i++){
1464
 
      direntry = direntries[i];
1465
 
      char *fullname = NULL;
1466
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1467
 
      if(ret < 0){
 
1945
    pid_t hook_pid = fork();
 
1946
    if(hook_pid == 0){
 
1947
      /* Child */
 
1948
      /* Raise privileges */
 
1949
      errno = raise_privileges_permanently();
 
1950
      if(errno != 0){
 
1951
        perror_plus("Failed to raise privileges");
 
1952
        _exit(EX_NOPERM);
 
1953
      }
 
1954
      /* Set group */
 
1955
      errno = 0;
 
1956
      ret = setgid(0);
 
1957
      if(ret == -1){
 
1958
        perror_plus("setgid");
 
1959
        _exit(EX_NOPERM);
 
1960
      }
 
1961
      /* Reset supplementary groups */
 
1962
      errno = 0;
 
1963
      ret = setgroups(0, NULL);
 
1964
      if(ret == -1){
 
1965
        perror_plus("setgroups");
 
1966
        _exit(EX_NOPERM);
 
1967
      }
 
1968
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1969
      if(ret == -1){
 
1970
        perror_plus("setenv");
 
1971
        _exit(EX_OSERR);
 
1972
      }
 
1973
      ret = setenv("DEVICE", interface, 1);
 
1974
      if(ret == -1){
 
1975
        perror_plus("setenv");
 
1976
        _exit(EX_OSERR);
 
1977
      }
 
1978
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1979
      if(ret == -1){
 
1980
        perror_plus("setenv");
 
1981
        _exit(EX_OSERR);
 
1982
      }
 
1983
      ret = setenv("MODE", mode, 1);
 
1984
      if(ret == -1){
 
1985
        perror_plus("setenv");
 
1986
        _exit(EX_OSERR);
 
1987
      }
 
1988
      char *delaystring;
 
1989
      ret = asprintf(&delaystring, "%f", (double)delay);
 
1990
      if(ret == -1){
1468
1991
        perror_plus("asprintf");
1469
 
        continue;
1470
 
      }
1471
 
      if(debug){
1472
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1473
 
                     direntry->d_name);
1474
 
      }
1475
 
      pid_t hook_pid = fork();
1476
 
      if(hook_pid == 0){
1477
 
        /* Child */
1478
 
        /* Raise privileges */
1479
 
        raise_privileges_permanently();
1480
 
        /* Set group */
1481
 
        errno = 0;
1482
 
        ret = setgid(0);
1483
 
        if(ret == -1){
1484
 
          perror_plus("setgid");
1485
 
        }
1486
 
        /* Reset supplementary groups */
1487
 
        errno = 0;
1488
 
        ret = setgroups(0, NULL);
1489
 
        if(ret == -1){
1490
 
          perror_plus("setgroups");
1491
 
        }
1492
 
        dup2(devnull, STDIN_FILENO);
1493
 
        close(devnull);
1494
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1495
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1496
 
        if(ret == -1){
1497
 
          perror_plus("setenv");
1498
 
          _exit(EX_OSERR);
1499
 
        }
1500
 
        ret = setenv("DEVICE", interface, 1);
1501
 
        if(ret == -1){
1502
 
          perror_plus("setenv");
1503
 
          _exit(EX_OSERR);
1504
 
        }
1505
 
        ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1506
 
        if(ret == -1){
1507
 
          perror_plus("setenv");
1508
 
          _exit(EX_OSERR);
1509
 
        }
1510
 
        ret = setenv("MODE", mode, 1);
1511
 
        if(ret == -1){
1512
 
          perror_plus("setenv");
1513
 
          _exit(EX_OSERR);
1514
 
        }
1515
 
        char *delaystring;
1516
 
        ret = asprintf(&delaystring, "%f", delay);
1517
 
        if(ret == -1){
1518
 
          perror_plus("asprintf");
1519
 
          _exit(EX_OSERR);
1520
 
        }
1521
 
        ret = setenv("DELAY", delaystring, 1);
1522
 
        if(ret == -1){
1523
 
          free(delaystring);
1524
 
          perror_plus("setenv");
1525
 
          _exit(EX_OSERR);
1526
 
        }
 
1992
        _exit(EX_OSERR);
 
1993
      }
 
1994
      ret = setenv("DELAY", delaystring, 1);
 
1995
      if(ret == -1){
1527
1996
        free(delaystring);
1528
 
        if(connect_to != NULL){
1529
 
          ret = setenv("CONNECT", connect_to, 1);
1530
 
          if(ret == -1){
1531
 
            perror_plus("setenv");
1532
 
            _exit(EX_OSERR);
1533
 
          }
1534
 
        }
1535
 
        if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1536
 
          perror_plus("execl");
1537
 
          _exit(EXIT_FAILURE);
1538
 
        }
 
1997
        perror_plus("setenv");
 
1998
        _exit(EX_OSERR);
 
1999
      }
 
2000
      free(delaystring);
 
2001
      if(connect_to != NULL){
 
2002
        ret = setenv("CONNECT", connect_to, 1);
 
2003
        if(ret == -1){
 
2004
          perror_plus("setenv");
 
2005
          _exit(EX_OSERR);
 
2006
        }
 
2007
      }
 
2008
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2009
                                                   direntry->d_name,
 
2010
                                                   O_RDONLY));
 
2011
      if(hook_fd == -1){
 
2012
        perror_plus("openat");
 
2013
        _exit(EXIT_FAILURE);
 
2014
      }
 
2015
      if(close(hookdir_fd) == -1){
 
2016
        perror_plus("close");
 
2017
        _exit(EXIT_FAILURE);
 
2018
      }
 
2019
      ret = dup2(devnull, STDIN_FILENO);
 
2020
      if(ret == -1){
 
2021
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
2022
        _exit(EX_OSERR);
 
2023
      }
 
2024
      ret = close(devnull);
 
2025
      if(ret == -1){
 
2026
        perror_plus("close");
 
2027
        _exit(EX_OSERR);
 
2028
      }
 
2029
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
2030
      if(ret == -1){
 
2031
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
2032
        _exit(EX_OSERR);
 
2033
      }
 
2034
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
2035
                 environ) == -1){
 
2036
        perror_plus("fexecve");
 
2037
        _exit(EXIT_FAILURE);
 
2038
      }
 
2039
    } else {
 
2040
      if(hook_pid == -1){
 
2041
        perror_plus("fork");
 
2042
        free(direntry);
 
2043
        continue;
 
2044
      }
 
2045
      int status;
 
2046
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
2047
        perror_plus("waitpid");
 
2048
        free(direntry);
 
2049
        continue;
 
2050
      }
 
2051
      if(WIFEXITED(status)){
 
2052
        if(WEXITSTATUS(status) != 0){
 
2053
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
2054
                       " with status %d\n", direntry->d_name,
 
2055
                       WEXITSTATUS(status));
 
2056
          free(direntry);
 
2057
          continue;
 
2058
        }
 
2059
      } else if(WIFSIGNALED(status)){
 
2060
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
2061
                     " signal %d\n", direntry->d_name,
 
2062
                     WTERMSIG(status));
 
2063
        free(direntry);
 
2064
        continue;
1539
2065
      } else {
1540
 
        int status;
1541
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1542
 
          perror_plus("waitpid");
1543
 
          free(fullname);
1544
 
          continue;
1545
 
        }
1546
 
        if(WIFEXITED(status)){
1547
 
          if(WEXITSTATUS(status) != 0){
1548
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1549
 
                         " with status %d\n", direntry->d_name,
1550
 
                         WEXITSTATUS(status));
1551
 
            free(fullname);
1552
 
            continue;
1553
 
          }
1554
 
        } else if(WIFSIGNALED(status)){
1555
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1556
 
                       " signal %d\n", direntry->d_name,
1557
 
                       WTERMSIG(status));
1558
 
          free(fullname);
1559
 
          continue;
1560
 
        } else {
1561
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1562
 
                       " crashed\n", direntry->d_name);
1563
 
          free(fullname);
1564
 
          continue;
1565
 
        }
1566
 
      }
1567
 
      free(fullname);
1568
 
      if(debug){
1569
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1570
 
                     direntry->d_name);
1571
 
      }
1572
 
    }
1573
 
    close(devnull);
1574
 
  }
1575
 
  return true;
 
2066
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
2067
                     " crashed\n", direntry->d_name);
 
2068
        free(direntry);
 
2069
        continue;
 
2070
      }
 
2071
    }
 
2072
    if(debug){
 
2073
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
2074
                   direntry->d_name);
 
2075
    }
 
2076
    free(direntry);
 
2077
  }
 
2078
  free(direntries);
 
2079
  if(close(hookdir_fd) == -1){
 
2080
    perror_plus("close");
 
2081
  } else {
 
2082
    hookdir_fd = -1;
 
2083
  }
 
2084
  close(devnull);
1576
2085
}
1577
2086
 
 
2087
__attribute__((nonnull, warn_unused_result))
1578
2088
error_t bring_up_interface(const char *const interface,
1579
2089
                           const float delay){
1580
 
  int sd = -1;
1581
2090
  error_t old_errno = errno;
1582
 
  error_t ret_errno = 0;
1583
 
  int ret, ret_setflags;
 
2091
  int ret;
1584
2092
  struct ifreq network;
1585
2093
  unsigned int if_index = if_nametoindex(interface);
1586
2094
  if(if_index == 0){
1595
2103
  }
1596
2104
  
1597
2105
  if(not interface_is_up(interface)){
1598
 
    if(not get_flags(interface, &network) and debug){
 
2106
    error_t ret_errno = 0, ioctl_errno = 0;
 
2107
    if(not get_flags(interface, &network)){
1599
2108
      ret_errno = errno;
1600
2109
      fprintf_plus(stderr, "Failed to get flags for interface "
1601
2110
                   "\"%s\"\n", interface);
 
2111
      errno = old_errno;
1602
2112
      return ret_errno;
1603
2113
    }
1604
 
    network.ifr_flags |= IFF_UP;
 
2114
    network.ifr_flags |= IFF_UP; /* set flag */
1605
2115
    
1606
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1607
 
    if(sd < 0){
 
2116
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2117
    if(sd == -1){
1608
2118
      ret_errno = errno;
1609
2119
      perror_plus("socket");
1610
2120
      errno = old_errno;
1611
2121
      return ret_errno;
1612
2122
    }
1613
 
  
 
2123
    
1614
2124
    if(quit_now){
1615
 
      close(sd);
 
2125
      ret = close(sd);
 
2126
      if(ret == -1){
 
2127
        perror_plus("close");
 
2128
      }
1616
2129
      errno = old_errno;
1617
2130
      return EINTR;
1618
2131
    }
1622
2135
                   interface);
1623
2136
    }
1624
2137
    
1625
 
    /* Raise priviliges */
1626
 
    raise_privileges();
 
2138
    /* Raise privileges */
 
2139
    ret_errno = raise_privileges();
 
2140
    if(ret_errno != 0){
 
2141
      errno = ret_errno;
 
2142
      perror_plus("Failed to raise privileges");
 
2143
    }
1627
2144
    
1628
2145
#ifdef __linux__
1629
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1630
 
       messages about the network interface to mess up the prompt */
1631
 
    int ret_linux = klogctl(8, NULL, 5);
1632
 
    bool restore_loglevel = true;
1633
 
    if(ret_linux == -1){
1634
 
      restore_loglevel = false;
1635
 
      perror_plus("klogctl");
 
2146
    int ret_linux;
 
2147
    bool restore_loglevel = false;
 
2148
    if(ret_errno == 0){
 
2149
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
2150
         messages about the network interface to mess up the prompt */
 
2151
      ret_linux = klogctl(8, NULL, 5);
 
2152
      if(ret_linux == -1){
 
2153
        perror_plus("klogctl");
 
2154
      } else {
 
2155
        restore_loglevel = true;
 
2156
      }
1636
2157
    }
1637
2158
#endif  /* __linux__ */
1638
 
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1639
 
    ret_errno = errno;
 
2159
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2160
    ioctl_errno = errno;
1640
2161
#ifdef __linux__
1641
2162
    if(restore_loglevel){
1642
2163
      ret_linux = klogctl(7, NULL, 0);
1646
2167
    }
1647
2168
#endif  /* __linux__ */
1648
2169
    
1649
 
    /* Lower privileges */
1650
 
    lower_privileges();
 
2170
    /* If raise_privileges() succeeded above */
 
2171
    if(ret_errno == 0){
 
2172
      /* Lower privileges */
 
2173
      ret_errno = lower_privileges();
 
2174
      if(ret_errno != 0){
 
2175
        errno = ret_errno;
 
2176
        perror_plus("Failed to lower privileges");
 
2177
      }
 
2178
    }
1651
2179
    
1652
2180
    /* Close the socket */
1653
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2181
    ret = close(sd);
1654
2182
    if(ret == -1){
1655
2183
      perror_plus("close");
1656
2184
    }
1657
2185
    
1658
2186
    if(ret_setflags == -1){
1659
 
      errno = ret_errno;
 
2187
      errno = ioctl_errno;
1660
2188
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1661
2189
      errno = old_errno;
1662
 
      return ret_errno;
 
2190
      return ioctl_errno;
1663
2191
    }
1664
2192
  } else if(debug){
1665
2193
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1683
2211
  return 0;
1684
2212
}
1685
2213
 
 
2214
__attribute__((nonnull, warn_unused_result))
1686
2215
error_t take_down_interface(const char *const interface){
1687
 
  int sd = -1;
1688
2216
  error_t old_errno = errno;
1689
 
  error_t ret_errno = 0;
1690
 
  int ret, ret_setflags;
1691
2217
  struct ifreq network;
1692
2218
  unsigned int if_index = if_nametoindex(interface);
1693
2219
  if(if_index == 0){
1696
2222
    return ENXIO;
1697
2223
  }
1698
2224
  if(interface_is_up(interface)){
 
2225
    error_t ret_errno = 0, ioctl_errno = 0;
1699
2226
    if(not get_flags(interface, &network) and debug){
1700
2227
      ret_errno = errno;
1701
2228
      fprintf_plus(stderr, "Failed to get flags for interface "
1702
2229
                   "\"%s\"\n", interface);
 
2230
      errno = old_errno;
1703
2231
      return ret_errno;
1704
2232
    }
1705
2233
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1706
2234
    
1707
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1708
 
    if(sd < 0){
 
2235
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2236
    if(sd == -1){
1709
2237
      ret_errno = errno;
1710
2238
      perror_plus("socket");
1711
2239
      errno = old_errno;
1717
2245
                   interface);
1718
2246
    }
1719
2247
    
1720
 
    /* Raise priviliges */
1721
 
    raise_privileges();
1722
 
    
1723
 
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1724
 
    ret_errno = errno;
1725
 
    
1726
 
    /* Lower privileges */
1727
 
    lower_privileges();
 
2248
    /* Raise privileges */
 
2249
    ret_errno = raise_privileges();
 
2250
    if(ret_errno != 0){
 
2251
      errno = ret_errno;
 
2252
      perror_plus("Failed to raise privileges");
 
2253
    }
 
2254
    
 
2255
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2256
    ioctl_errno = errno;
 
2257
    
 
2258
    /* If raise_privileges() succeeded above */
 
2259
    if(ret_errno == 0){
 
2260
      /* Lower privileges */
 
2261
      ret_errno = lower_privileges();
 
2262
      if(ret_errno != 0){
 
2263
        errno = ret_errno;
 
2264
        perror_plus("Failed to lower privileges");
 
2265
      }
 
2266
    }
1728
2267
    
1729
2268
    /* Close the socket */
1730
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2269
    int ret = close(sd);
1731
2270
    if(ret == -1){
1732
2271
      perror_plus("close");
1733
2272
    }
1734
2273
    
1735
2274
    if(ret_setflags == -1){
1736
 
      errno = ret_errno;
 
2275
      errno = ioctl_errno;
1737
2276
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1738
2277
      errno = old_errno;
1739
 
      return ret_errno;
 
2278
      return ioctl_errno;
1740
2279
    }
1741
2280
  } else if(debug){
1742
2281
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1748
2287
}
1749
2288
 
1750
2289
int main(int argc, char *argv[]){
 
2290
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2291
                        .priority = "SECURE256:!CTYPE-X.509"
 
2292
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2293
                        .current_server = NULL, .interfaces = NULL,
 
2294
                        .interfaces_size = 0 };
1751
2295
  AvahiSServiceBrowser *sb = NULL;
1752
2296
  error_t ret_errno;
1753
2297
  int ret;
1754
2298
  intmax_t tmpmax;
1755
2299
  char *tmp;
1756
2300
  int exitcode = EXIT_SUCCESS;
1757
 
  char *interfaces = NULL;
1758
 
  size_t interfaces_size = 0;
1759
2301
  char *interfaces_to_take_down = NULL;
1760
2302
  size_t interfaces_to_take_down_size = 0;
1761
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1762
 
  bool tempdir_created = false;
 
2303
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2304
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2305
  char *tempdir = NULL;
1763
2306
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1764
2307
  const char *seckey = PATHDIR "/" SECKEY;
1765
2308
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2309
  const char *dh_params_file = NULL;
1766
2310
  char *interfaces_hooks = NULL;
1767
 
  size_t interfaces_hooks_size = 0;
1768
2311
  
1769
2312
  bool gnutls_initialized = false;
1770
2313
  bool gpgme_initialized = false;
1822
2365
        .doc = "Bit length of the prime number used in the"
1823
2366
        " Diffie-Hellman key exchange",
1824
2367
        .group = 2 },
 
2368
      { .name = "dh-params", .key = 134,
 
2369
        .arg = "FILE",
 
2370
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
 
2371
        " for the Diffie-Hellman key exchange",
 
2372
        .group = 2 },
1825
2373
      { .name = "priority", .key = 130,
1826
2374
        .arg = "STRING",
1827
2375
        .doc = "GnuTLS priority string for the TLS handshake",
1861
2409
        connect_to = arg;
1862
2410
        break;
1863
2411
      case 'i':                 /* --interface */
1864
 
        ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
1865
 
                                 (int)',');
 
2412
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2413
                                 arg, (int)',');
1866
2414
        if(ret_errno != 0){
1867
2415
          argp_error(state, "%s", strerror(ret_errno));
1868
2416
        }
1882
2430
        }
1883
2431
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1884
2432
        break;
 
2433
      case 134:                 /* --dh-params */
 
2434
        dh_params_file = arg;
 
2435
        break;
1885
2436
      case 130:                 /* --priority */
1886
2437
        mc.priority = arg;
1887
2438
        break;
1943
2494
      goto end;
1944
2495
    }
1945
2496
  }
1946
 
    
 
2497
  
1947
2498
  {
1948
2499
    /* Work around Debian bug #633582:
1949
2500
       <http://bugs.debian.org/633582> */
1950
2501
    
1951
 
    /* Re-raise priviliges */
1952
 
    if(raise_privileges() == 0){
 
2502
    /* Re-raise privileges */
 
2503
    ret_errno = raise_privileges();
 
2504
    if(ret_errno != 0){
 
2505
      errno = ret_errno;
 
2506
      perror_plus("Failed to raise privileges");
 
2507
    } else {
1953
2508
      struct stat st;
1954
2509
      
1955
2510
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1969
2524
              }
1970
2525
            }
1971
2526
          }
1972
 
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2527
          close(seckey_fd);
1973
2528
        }
1974
2529
      }
1975
 
    
 
2530
      
1976
2531
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1977
2532
        int pubkey_fd = open(pubkey, O_RDONLY);
1978
2533
        if(pubkey_fd == -1){
1990
2545
              }
1991
2546
            }
1992
2547
          }
1993
 
          TEMP_FAILURE_RETRY(close(pubkey_fd));
1994
 
        }
1995
 
      }
1996
 
    
 
2548
          close(pubkey_fd);
 
2549
        }
 
2550
      }
 
2551
      
 
2552
      if(dh_params_file != NULL
 
2553
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2554
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2555
        if(dhparams_fd == -1){
 
2556
          perror_plus("open");
 
2557
        } else {
 
2558
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2559
          if(ret == -1){
 
2560
            perror_plus("fstat");
 
2561
          } else {
 
2562
            if(S_ISREG(st.st_mode)
 
2563
               and st.st_uid == 0 and st.st_gid == 0){
 
2564
              ret = fchown(dhparams_fd, uid, gid);
 
2565
              if(ret == -1){
 
2566
                perror_plus("fchown");
 
2567
              }
 
2568
            }
 
2569
          }
 
2570
          close(dhparams_fd);
 
2571
        }
 
2572
      }
 
2573
      
1997
2574
      /* Lower privileges */
1998
 
      errno = 0;
1999
 
      ret = seteuid(uid);
2000
 
      if(ret == -1){
2001
 
        perror_plus("seteuid");
 
2575
      ret_errno = lower_privileges();
 
2576
      if(ret_errno != 0){
 
2577
        errno = ret_errno;
 
2578
        perror_plus("Failed to lower privileges");
2002
2579
      }
2003
2580
    }
2004
2581
  }
2005
2582
  
2006
 
  /* Remove empty interface names */
 
2583
  /* Remove invalid interface names (except "none") */
2007
2584
  {
2008
2585
    char *interface = NULL;
2009
 
    while((interface = argz_next(interfaces, interfaces_size,
 
2586
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2010
2587
                                 interface))){
2011
 
      if(if_nametoindex(interface) == 0){
2012
 
        if(interface[0] != '\0' and strcmp(interface, "none") != 0){
 
2588
      if(strcmp(interface, "none") != 0
 
2589
         and if_nametoindex(interface) == 0){
 
2590
        if(interface[0] != '\0'){
2013
2591
          fprintf_plus(stderr, "Not using nonexisting interface"
2014
2592
                       " \"%s\"\n", interface);
2015
2593
        }
2016
 
        argz_delete(&interfaces, &interfaces_size, interface);
 
2594
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2017
2595
        interface = NULL;
2018
2596
      }
2019
2597
    }
2021
2599
  
2022
2600
  /* Run network hooks */
2023
2601
  {
2024
 
    
2025
 
    if(interfaces != NULL){
2026
 
      interfaces_hooks = malloc(interfaces_size);
 
2602
    if(mc.interfaces != NULL){
 
2603
      interfaces_hooks = malloc(mc.interfaces_size);
2027
2604
      if(interfaces_hooks == NULL){
2028
2605
        perror_plus("malloc");
2029
2606
        goto end;
2030
2607
      }
2031
 
      memcpy(interfaces_hooks, interfaces, interfaces_size);
2032
 
      interfaces_hooks_size = interfaces_size;
2033
 
      argz_stringify(interfaces_hooks, interfaces_hooks_size,
2034
 
                     (int)',');
2035
 
    }
2036
 
    if(not run_network_hooks("start", interfaces_hooks != NULL ?
2037
 
                             interfaces_hooks : "", delay)){
2038
 
      goto end;
2039
 
    }
 
2608
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2609
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2610
    }
 
2611
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2612
                      interfaces_hooks : "", delay);
2040
2613
  }
2041
2614
  
2042
2615
  if(not debug){
2047
2620
     from the signal handler */
2048
2621
  /* Initialize the pseudo-RNG for Avahi */
2049
2622
  srand((unsigned int) time(NULL));
2050
 
  mc.simple_poll = avahi_simple_poll_new();
2051
 
  if(mc.simple_poll == NULL){
 
2623
  simple_poll = avahi_simple_poll_new();
 
2624
  if(simple_poll == NULL){
2052
2625
    fprintf_plus(stderr,
2053
2626
                 "Avahi: Failed to create simple poll object.\n");
2054
2627
    exitcode = EX_UNAVAILABLE;
2119
2692
  }
2120
2693
  
2121
2694
  /* If no interfaces were specified, make a list */
2122
 
  if(interfaces == NULL){
2123
 
    struct dirent **direntries;
 
2695
  if(mc.interfaces == NULL){
 
2696
    struct dirent **direntries = NULL;
2124
2697
    /* Look for any good interfaces */
2125
2698
    ret = scandir(sys_class_net, &direntries, good_interface,
2126
2699
                  alphasort);
2127
2700
    if(ret >= 1){
2128
2701
      /* Add all found interfaces to interfaces list */
2129
2702
      for(int i = 0; i < ret; ++i){
2130
 
        ret_errno = argz_add(&interfaces, &interfaces_size,
 
2703
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2131
2704
                             direntries[i]->d_name);
2132
2705
        if(ret_errno != 0){
 
2706
          errno = ret_errno;
2133
2707
          perror_plus("argz_add");
 
2708
          free(direntries[i]);
2134
2709
          continue;
2135
2710
        }
2136
2711
        if(debug){
2137
2712
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
2138
2713
                       direntries[i]->d_name);
2139
2714
        }
 
2715
        free(direntries[i]);
2140
2716
      }
2141
2717
      free(direntries);
2142
2718
    } else {
2143
 
      free(direntries);
 
2719
      if(ret == 0){
 
2720
        free(direntries);
 
2721
      }
2144
2722
      fprintf_plus(stderr, "Could not find a network interface\n");
2145
2723
      exitcode = EXIT_FAILURE;
2146
2724
      goto end;
2147
2725
    }
2148
2726
  }
2149
2727
  
2150
 
  /* If we only got one interface, explicitly use only that one */
2151
 
  if(argz_count(interfaces, interfaces_size) == 1){
2152
 
    if(debug){
2153
 
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
2154
 
                   interfaces);
2155
 
    }
2156
 
    if_index = (AvahiIfIndex)if_nametoindex(interfaces);
2157
 
  }
2158
 
  
2159
 
  /* Bring up interfaces which are down */
2160
 
  if(not (argz_count(interfaces, interfaces_size) == 1
2161
 
          and strcmp(interfaces, "none") == 0)){
 
2728
  /* Bring up interfaces which are down, and remove any "none"s */
 
2729
  {
2162
2730
    char *interface = NULL;
2163
 
    while((interface = argz_next(interfaces, interfaces_size,
 
2731
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2164
2732
                                 interface))){
 
2733
      /* If interface name is "none", stop bringing up interfaces.
 
2734
         Also remove all instances of "none" from the list */
 
2735
      if(strcmp(interface, "none") == 0){
 
2736
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2737
                    interface);
 
2738
        interface = NULL;
 
2739
        while((interface = argz_next(mc.interfaces,
 
2740
                                     mc.interfaces_size, interface))){
 
2741
          if(strcmp(interface, "none") == 0){
 
2742
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2743
                        interface);
 
2744
            interface = NULL;
 
2745
          }
 
2746
        }
 
2747
        break;
 
2748
      }
2165
2749
      bool interface_was_up = interface_is_up(interface);
2166
 
      ret = bring_up_interface(interface, delay);
 
2750
      errno = bring_up_interface(interface, delay);
2167
2751
      if(not interface_was_up){
2168
 
        if(ret != 0){
2169
 
          errno = ret;
2170
 
          perror_plus("Failed to bring up interface");
 
2752
        if(errno != 0){
 
2753
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2754
                       " %s\n", interface, strerror(errno));
2171
2755
        } else {
2172
 
          ret_errno = argz_add(&interfaces_to_take_down,
2173
 
                               &interfaces_to_take_down_size,
2174
 
                               interface);
 
2756
          errno = argz_add(&interfaces_to_take_down,
 
2757
                           &interfaces_to_take_down_size,
 
2758
                           interface);
 
2759
          if(errno != 0){
 
2760
            perror_plus("argz_add");
 
2761
          }
2175
2762
        }
2176
2763
      }
2177
2764
    }
2178
 
    free(interfaces);
2179
 
    interfaces = NULL;
2180
 
    interfaces_size = 0;
2181
2765
    if(debug and (interfaces_to_take_down == NULL)){
2182
2766
      fprintf_plus(stderr, "No interfaces were brought up\n");
2183
2767
    }
2184
2768
  }
2185
2769
  
 
2770
  /* If we only got one interface, explicitly use only that one */
 
2771
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2772
    if(debug){
 
2773
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2774
                   mc.interfaces);
 
2775
    }
 
2776
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
 
2777
  }
 
2778
  
2186
2779
  if(quit_now){
2187
2780
    goto end;
2188
2781
  }
2189
2782
  
2190
 
  ret = init_gnutls_global(pubkey, seckey);
 
2783
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2191
2784
  if(ret == -1){
2192
2785
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2193
2786
    exitcode = EX_UNAVAILABLE;
2200
2793
    goto end;
2201
2794
  }
2202
2795
  
2203
 
  if(mkdtemp(tempdir) == NULL){
 
2796
  /* Try /run/tmp before /tmp */
 
2797
  tempdir = mkdtemp(run_tempdir);
 
2798
  if(tempdir == NULL and errno == ENOENT){
 
2799
      if(debug){
 
2800
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
2801
                     run_tempdir, old_tempdir);
 
2802
      }
 
2803
      tempdir = mkdtemp(old_tempdir);
 
2804
  }
 
2805
  if(tempdir == NULL){
2204
2806
    perror_plus("mkdtemp");
2205
2807
    goto end;
2206
2808
  }
2207
 
  tempdir_created = true;
2208
2809
  
2209
2810
  if(quit_now){
2210
2811
    goto end;
2211
2812
  }
2212
2813
  
2213
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
2814
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2214
2815
    fprintf_plus(stderr, "init_gpgme failed\n");
2215
2816
    exitcode = EX_UNAVAILABLE;
2216
2817
    goto end;
2246
2847
      exitcode = EX_USAGE;
2247
2848
      goto end;
2248
2849
    }
2249
 
  
 
2850
    
2250
2851
    if(quit_now){
2251
2852
      goto end;
2252
2853
    }
2273
2874
    }
2274
2875
    
2275
2876
    while(not quit_now){
2276
 
      ret = start_mandos_communication(address, port, if_index, af);
 
2877
      ret = start_mandos_communication(address, port, if_index, af,
 
2878
                                       &mc);
2277
2879
      if(quit_now or ret == 0){
2278
2880
        break;
2279
2881
      }
2281
2883
        fprintf_plus(stderr, "Retrying in %d seconds\n",
2282
2884
                     (int)retry_interval);
2283
2885
      }
2284
 
      sleep((int)retry_interval);
 
2886
      sleep((unsigned int)retry_interval);
2285
2887
    }
2286
2888
    
2287
 
    if (not quit_now){
 
2889
    if(not quit_now){
2288
2890
      exitcode = EXIT_SUCCESS;
2289
2891
    }
2290
2892
    
2305
2907
    config.publish_domain = 0;
2306
2908
    
2307
2909
    /* Allocate a new server */
2308
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2309
 
                                 (mc.simple_poll), &config, NULL,
2310
 
                                 NULL, &ret_errno);
 
2910
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
2911
                                 &config, NULL, NULL, &ret_errno);
2311
2912
    
2312
2913
    /* Free the Avahi configuration data */
2313
2914
    avahi_server_config_free(&config);
2328
2929
  /* Create the Avahi service browser */
2329
2930
  sb = avahi_s_service_browser_new(mc.server, if_index,
2330
2931
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2331
 
                                   NULL, 0, browse_callback, NULL);
 
2932
                                   NULL, 0, browse_callback,
 
2933
                                   (void *)&mc);
2332
2934
  if(sb == NULL){
2333
2935
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
2334
2936
                 avahi_strerror(avahi_server_errno(mc.server)));
2345
2947
  if(debug){
2346
2948
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2347
2949
  }
2348
 
 
2349
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2350
 
                                (int)(retry_interval * 1000));
 
2950
  
 
2951
  ret = avahi_loop_with_timeout(simple_poll,
 
2952
                                (int)(retry_interval * 1000), &mc);
2351
2953
  if(debug){
2352
2954
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2353
2955
                 (ret == 0) ? "successfully" : "with error");
2360
2962
  }
2361
2963
  
2362
2964
  /* Cleanup things */
 
2965
  free(mc.interfaces);
 
2966
  
2363
2967
  if(sb != NULL)
2364
2968
    avahi_s_service_browser_free(sb);
2365
2969
  
2366
2970
  if(mc.server != NULL)
2367
2971
    avahi_server_free(mc.server);
2368
2972
  
2369
 
  if(mc.simple_poll != NULL)
2370
 
    avahi_simple_poll_free(mc.simple_poll);
 
2973
  if(simple_poll != NULL)
 
2974
    avahi_simple_poll_free(simple_poll);
2371
2975
  
2372
2976
  if(gnutls_initialized){
2373
2977
    gnutls_certificate_free_credentials(mc.cred);
2385
2989
    mc.current_server->prev->next = NULL;
2386
2990
    while(mc.current_server != NULL){
2387
2991
      server *next = mc.current_server->next;
 
2992
#ifdef __GNUC__
 
2993
#pragma GCC diagnostic push
 
2994
#pragma GCC diagnostic ignored "-Wcast-qual"
 
2995
#endif
 
2996
      free((char *)(mc.current_server->ip));
 
2997
#ifdef __GNUC__
 
2998
#pragma GCC diagnostic pop
 
2999
#endif
2388
3000
      free(mc.current_server);
2389
3001
      mc.current_server = next;
2390
3002
    }
2391
3003
  }
2392
3004
  
2393
 
  /* Re-raise priviliges */
 
3005
  /* Re-raise privileges */
2394
3006
  {
2395
 
    raise_privileges();
2396
 
    
2397
 
    /* Run network hooks */
2398
 
    run_network_hooks("stop", interfaces_hooks != NULL ?
2399
 
                      interfaces_hooks : "", delay);
2400
 
    
2401
 
    /* Take down the network interfaces which were brought up */
2402
 
    {
2403
 
      char *interface = NULL;
2404
 
      while((interface=argz_next(interfaces_to_take_down,
2405
 
                                 interfaces_to_take_down_size,
2406
 
                                 interface))){
2407
 
        ret_errno = take_down_interface(interface);
2408
 
        if(ret_errno != 0){
2409
 
          errno = ret_errno;
2410
 
          perror_plus("Failed to take down interface");
2411
 
        }
2412
 
      }
2413
 
      if(debug and (interfaces_to_take_down == NULL)){
2414
 
        fprintf_plus(stderr, "No interfaces needed to be taken"
2415
 
                     " down\n");
2416
 
      }
2417
 
    }
2418
 
    
2419
 
    lower_privileges_permanently();
 
3007
    ret_errno = raise_privileges();
 
3008
    if(ret_errno != 0){
 
3009
      errno = ret_errno;
 
3010
      perror_plus("Failed to raise privileges");
 
3011
    } else {
 
3012
      
 
3013
      /* Run network hooks */
 
3014
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
3015
                        interfaces_hooks : "", delay);
 
3016
      
 
3017
      /* Take down the network interfaces which were brought up */
 
3018
      {
 
3019
        char *interface = NULL;
 
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;
 
3026
            perror_plus("Failed to take down interface");
 
3027
          }
 
3028
        }
 
3029
        if(debug and (interfaces_to_take_down == NULL)){
 
3030
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
3031
                       " down\n");
 
3032
        }
 
3033
      }
 
3034
    }
 
3035
    
 
3036
    ret_errno = lower_privileges_permanently();
 
3037
    if(ret_errno != 0){
 
3038
      errno = ret_errno;
 
3039
      perror_plus("Failed to lower privileges permanently");
 
3040
    }
2420
3041
  }
2421
3042
  
2422
3043
  free(interfaces_to_take_down);
2423
3044
  free(interfaces_hooks);
2424
3045
  
2425
3046
  /* Removes the GPGME temp directory and all files inside */
2426
 
  if(tempdir_created){
 
3047
  if(tempdir != NULL){
2427
3048
    struct dirent **direntries = NULL;
2428
 
    struct dirent *direntry = NULL;
2429
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2430
 
                             alphasort);
2431
 
    if (numentries > 0){
2432
 
      for(int i = 0; i < numentries; i++){
2433
 
        direntry = direntries[i];
2434
 
        char *fullname = NULL;
2435
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2436
 
                       direntry->d_name);
2437
 
        if(ret < 0){
2438
 
          perror_plus("asprintf");
2439
 
          continue;
2440
 
        }
2441
 
        ret = remove(fullname);
2442
 
        if(ret == -1){
2443
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2444
 
                       strerror(errno));
2445
 
        }
2446
 
        free(fullname);
 
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
        }
2447
3088
      }
2448
 
    }
2449
 
 
2450
 
    /* need to clean even if 0 because man page doesn't specify */
2451
 
    free(direntries);
2452
 
    if (numentries == -1){
2453
 
      perror_plus("scandir");
2454
 
    }
2455
 
    ret = rmdir(tempdir);
2456
 
    if(ret == -1 and errno != ENOENT){
2457
 
      perror_plus("rmdir");
 
3089
      close(tempdir_fd);
2458
3090
    }
2459
3091
  }
2460
3092