/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
 
180
185
  perror(print_text);
181
186
}
182
187
 
183
 
__attribute__((format (gnu_printf, 2, 3)))
 
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
184
189
int fprintf_plus(FILE *stream, const char *format, ...){
185
190
  va_list ap;
186
191
  va_start (ap, format);
195
200
 * bytes. "buffer_capacity" is how much is currently allocated,
196
201
 * "buffer_length" is how much is already used.
197
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
198
204
size_t incbuffer(char **buffer, size_t buffer_length,
199
205
                 size_t buffer_capacity){
200
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
201
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
202
 
    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;
203
213
      return 0;
204
214
    }
 
215
    *buffer = new_buf;
205
216
    buffer_capacity += BUFFER_SIZE;
206
217
  }
207
218
  return buffer_capacity;
208
219
}
209
220
 
210
221
/* Add server to set of servers to retry periodically */
 
222
__attribute__((nonnull, warn_unused_result))
211
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
212
224
                int af, server **current_server){
213
225
  int ret;
222
234
                          .af = af };
223
235
  if(new_server->ip == NULL){
224
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);
225
252
    return false;
226
253
  }
227
254
  /* Special case of first server */
229
256
    new_server->next = new_server;
230
257
    new_server->prev = new_server;
231
258
    *current_server = new_server;
232
 
  /* Place the new server last in the list */
233
259
  } else {
 
260
    /* Place the new server last in the list */
234
261
    new_server->next = *current_server;
235
262
    new_server->prev = (*current_server)->prev;
236
263
    new_server->prev->next = new_server;
237
264
    (*current_server)->prev = new_server;
238
265
  }
239
 
  ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
240
 
  if(ret == -1){
241
 
    perror_plus("clock_gettime");
242
 
    return false;
243
 
  }
244
266
  return true;
245
267
}
246
268
 
247
269
/* 
248
270
 * Initialize GPGME.
249
271
 */
250
 
static bool init_gpgme(const char *seckey, const char *pubkey,
251
 
                       const char *tempdir, mandos_context *mc){
 
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){
252
277
  gpgme_error_t rc;
253
278
  gpgme_engine_info_t engine_info;
254
279
  
255
280
  /*
256
281
   * Helper function to insert pub and seckey to the engine keyring.
257
282
   */
258
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
259
284
    int ret;
260
285
    int fd;
261
286
    gpgme_data_t pgp_data;
280
305
      return false;
281
306
    }
282
307
    
283
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
308
    ret = close(fd);
284
309
    if(ret == -1){
285
310
      perror_plus("close");
286
311
    }
342
367
 * Decrypt OpenPGP data.
343
368
 * Returns -1 on error
344
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
345
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
372
                                  size_t crypto_size,
347
373
                                  char **plaintext,
467
493
  return plaintext_length;
468
494
}
469
495
 
470
 
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){
471
505
  const char *ret = gnutls_strerror(value);
472
 
  if(ret == NULL)
473
 
    ret = "(unknown)";
474
 
  return ret;
 
506
  return safe_string(ret);
475
507
}
476
508
 
477
509
/* GnuTLS log function callback */
 
510
__attribute__((nonnull))
478
511
static void debuggnutls(__attribute__((unused)) int level,
479
512
                        const char* string){
480
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
481
514
}
482
515
 
 
516
__attribute__((nonnull, warn_unused_result))
483
517
static int init_gnutls_global(const char *pubkeyfilename,
484
518
                              const char *seckeyfilename,
 
519
                              const char *dhparamsfilename,
485
520
                              mandos_context *mc){
486
521
  int ret;
 
522
  unsigned int uret;
487
523
  
488
524
  if(debug){
489
525
    fprintf_plus(stderr, "Initializing GnuTLS\n");
540
576
                 safer_gnutls_strerror(ret));
541
577
    goto globalfail;
542
578
  }
543
 
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
544
 
  if(ret != GNUTLS_E_SUCCESS){
545
 
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
546
 
                 safer_gnutls_strerror(ret));
547
 
    goto globalfail;
548
 
  }
549
 
  
 
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
  }
550
751
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
551
752
  
552
753
  return 0;
559
760
  return -1;
560
761
}
561
762
 
 
763
__attribute__((nonnull, warn_unused_result))
562
764
static int init_gnutls_session(gnutls_session_t *session,
563
765
                               mandos_context *mc){
564
766
  int ret;
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
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
  
701
1118
                 PRIuMAX "\n", ip, (uintmax_t)port);
702
1119
  }
703
1120
  
704
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1121
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
705
1122
  if(tcp_sd < 0){
706
1123
    int e = errno;
707
1124
    perror_plus("socket");
714
1131
    goto mandos_end;
715
1132
  }
716
1133
  
717
 
  memset(&to, 0, sizeof(to));
718
1134
  if(af == AF_INET6){
719
 
    to.in6.sin6_family = (sa_family_t)af;
720
 
    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);
721
1138
  } else {                      /* IPv4 */
722
 
    to.in.sin_family = (sa_family_t)af;
723
 
    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);
724
1142
  }
725
1143
  if(ret < 0 ){
726
1144
    int e = errno;
735
1153
    goto mandos_end;
736
1154
  }
737
1155
  if(af == AF_INET6){
738
 
    to.in6.sin6_port = htons(port);    
739
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
740
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
741
 
                                -Wunreachable-code*/
 
1156
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
1157
    if(IN6_IS_ADDR_LINKLOCAL
 
1158
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
742
1159
      if(if_index == AVAHI_IF_UNSPEC){
743
1160
        fprintf_plus(stderr, "An IPv6 link-local address is"
744
1161
                     " incomplete without a network interface\n");
746
1163
        goto mandos_end;
747
1164
      }
748
1165
      /* Set the network interface number as scope */
749
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
1166
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
750
1167
    }
751
1168
  } else {
752
 
    to.in.sin_port = htons(port); /* Spurious warnings from
753
 
                                     -Wconversion and
754
 
                                     -Wunreachable-code */
 
1169
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
755
1170
  }
756
1171
  
757
1172
  if(quit_now){
774
1189
    }
775
1190
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
776
1191
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
777
 
    const char *pcret;
778
 
    if(af == AF_INET6){
779
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
780
 
                        sizeof(addrstr));
781
 
    } else {
782
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
783
 
                        sizeof(addrstr));
784
 
    }
785
 
    if(pcret == NULL){
786
 
      perror_plus("inet_ntop");
787
 
    } else {
788
 
      if(strcmp(addrstr, ip) != 0){
789
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
790
 
      }
791
 
    }
792
 
  }
793
 
  
794
 
  if(quit_now){
795
 
    errno = EINTR;
796
 
    goto mandos_end;
797
 
  }
798
 
  
799
 
  if(af == AF_INET6){
800
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
801
 
  } else {
802
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
803
 
  }
804
 
  if(ret < 0){
805
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
806
 
      int e = errno;
807
 
      perror_plus("connect");
808
 
      errno = e;
809
 
    }
810
 
    goto mandos_end;
811
 
  }
812
 
  
813
 
  if(quit_now){
814
 
    errno = EINTR;
815
 
    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;
816
1272
  }
817
1273
  
818
1274
  const char *out = mandos_protocol_version;
1001
1457
  
1002
1458
 mandos_end:
1003
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
    }
1004
1466
    int e = errno;
1005
1467
    free(decrypted_buffer);
1006
1468
    free(buffer);
1007
1469
    if(tcp_sd >= 0){
1008
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1470
      ret = close(tcp_sd);
1009
1471
    }
1010
1472
    if(ret == -1){
1011
1473
      if(e == 0){
1023
1485
  return retval;
1024
1486
}
1025
1487
 
 
1488
__attribute__((nonnull))
1026
1489
static void resolve_callback(AvahiSServiceResolver *r,
1027
1490
                             AvahiIfIndex interface,
1028
1491
                             AvahiProtocol proto,
1036
1499
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
1037
1500
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
1038
1501
                             flags,
1039
 
                             void* mc){
 
1502
                             void *mc){
1040
1503
  if(r == NULL){
1041
1504
    return;
1042
1505
  }
1045
1508
     timed out */
1046
1509
  
1047
1510
  if(quit_now){
 
1511
    avahi_s_service_resolver_free(r);
1048
1512
    return;
1049
1513
  }
1050
1514
  
1095
1559
                            const char *domain,
1096
1560
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1097
1561
                            flags,
1098
 
                            void* mc){
 
1562
                            void *mc){
1099
1563
  if(b == NULL){
1100
1564
    return;
1101
1565
  }
1161
1625
  errno = old_errno;
1162
1626
}
1163
1627
 
 
1628
__attribute__((nonnull, warn_unused_result))
1164
1629
bool get_flags(const char *ifname, struct ifreq *ifr){
1165
1630
  int ret;
1166
1631
  error_t ret_errno;
1185
1650
  return true;
1186
1651
}
1187
1652
 
 
1653
__attribute__((nonnull, warn_unused_result))
1188
1654
bool good_flags(const char *ifname, const struct ifreq *ifr){
1189
1655
  
1190
1656
  /* Reject the loopback device */
1232
1698
 * corresponds to an acceptable network device.
1233
1699
 * (This function is passed to scandir(3) as a filter function.)
1234
1700
 */
 
1701
__attribute__((nonnull, warn_unused_result))
1235
1702
int good_interface(const struct dirent *if_entry){
1236
1703
  if(if_entry->d_name[0] == '.'){
1237
1704
    return 0;
1255
1722
/* 
1256
1723
 * This function determines if a network interface is up.
1257
1724
 */
 
1725
__attribute__((nonnull, warn_unused_result))
1258
1726
bool interface_is_up(const char *interface){
1259
1727
  struct ifreq ifr;
1260
1728
  if(not get_flags(interface, &ifr)){
1271
1739
/* 
1272
1740
 * This function determines if a network interface is running
1273
1741
 */
 
1742
__attribute__((nonnull, warn_unused_result))
1274
1743
bool interface_is_running(const char *interface){
1275
1744
  struct ifreq ifr;
1276
1745
  if(not get_flags(interface, &ifr)){
1284
1753
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
1285
1754
}
1286
1755
 
 
1756
__attribute__((nonnull, pure, warn_unused_result))
1287
1757
int notdotentries(const struct dirent *direntry){
1288
1758
  /* Skip "." and ".." */
1289
1759
  if(direntry->d_name[0] == '.'
1296
1766
}
1297
1767
 
1298
1768
/* Is this directory entry a runnable program? */
 
1769
__attribute__((nonnull, warn_unused_result))
1299
1770
int runnable_hook(const struct dirent *direntry){
1300
1771
  int ret;
1301
1772
  size_t sret;
1309
1780
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1310
1781
                "abcdefghijklmnopqrstuvwxyz"
1311
1782
                "0123456789"
1312
 
                "_-");
 
1783
                "_.-");
1313
1784
  if((direntry->d_name)[sret] != '\0'){
1314
1785
    /* Contains non-allowed characters */
1315
1786
    if(debug){
1319
1790
    return 0;
1320
1791
  }
1321
1792
  
1322
 
  char *fullname = NULL;
1323
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1324
 
  if(ret < 0){
1325
 
    perror_plus("asprintf");
1326
 
    return 0;
1327
 
  }
1328
 
  
1329
 
  ret = stat(fullname, &st);
 
1793
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1330
1794
  if(ret == -1){
1331
1795
    if(debug){
1332
1796
      perror_plus("Could not stat hook");
1356
1820
  return 1;
1357
1821
}
1358
1822
 
 
1823
__attribute__((nonnull, warn_unused_result))
1359
1824
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1360
1825
                            mandos_context *mc){
1361
1826
  int ret;
1365
1830
  
1366
1831
  while(true){
1367
1832
    if(mc->current_server == NULL){
1368
 
      if (debug){
 
1833
      if(debug){
1369
1834
        fprintf_plus(stderr, "Wait until first server is found."
1370
1835
                     " No timeout!\n");
1371
1836
      }
1372
1837
      ret = avahi_simple_poll_iterate(s, -1);
1373
1838
    } else {
1374
 
      if (debug){
 
1839
      if(debug){
1375
1840
        fprintf_plus(stderr, "Check current_server if we should run"
1376
1841
                     " it, or wait\n");
1377
1842
      }
1394
1859
                     - ((intmax_t)waited_time.tv_sec * 1000))
1395
1860
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1396
1861
      
1397
 
      if (debug){
 
1862
      if(debug){
1398
1863
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1399
1864
                     block_time);
1400
1865
      }
1422
1887
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1423
1888
    }
1424
1889
    if(ret != 0){
1425
 
      if (ret > 0 or errno != EINTR){
 
1890
      if(ret > 0 or errno != EINTR){
1426
1891
        return (ret != 1) ? ret : 0;
1427
1892
      }
1428
1893
    }
1429
1894
  }
1430
1895
}
1431
1896
 
1432
 
/* Set effective uid to 0, return errno */
1433
 
error_t raise_privileges(void){
1434
 
  error_t old_errno = errno;
1435
 
  error_t ret_errno = 0;
1436
 
  if(seteuid(0) == -1){
1437
 
    ret_errno = errno;
1438
 
    perror_plus("seteuid");
1439
 
  }
1440
 
  errno = old_errno;
1441
 
  return ret_errno;
1442
 
}
1443
 
 
1444
 
/* Set effective and real user ID to 0.  Return errno. */
1445
 
error_t raise_privileges_permanently(void){
1446
 
  error_t old_errno = errno;
1447
 
  error_t ret_errno = raise_privileges();
1448
 
  if(ret_errno != 0){
1449
 
    errno = old_errno;
1450
 
    return ret_errno;
1451
 
  }
1452
 
  if(setuid(0) == -1){
1453
 
    ret_errno = errno;
1454
 
    perror_plus("seteuid");
1455
 
  }
1456
 
  errno = old_errno;
1457
 
  return ret_errno;
1458
 
}
1459
 
 
1460
 
/* Set effective user ID to unprivileged saved user ID */
1461
 
error_t lower_privileges(void){
1462
 
  error_t old_errno = errno;
1463
 
  error_t ret_errno = 0;
1464
 
  if(seteuid(uid) == -1){
1465
 
    ret_errno = errno;
1466
 
    perror_plus("seteuid");
1467
 
  }
1468
 
  errno = old_errno;
1469
 
  return ret_errno;
1470
 
}
1471
 
 
1472
 
/* Lower privileges permanently */
1473
 
error_t lower_privileges_permanently(void){
1474
 
  error_t old_errno = errno;
1475
 
  error_t ret_errno = 0;
1476
 
  if(setuid(uid) == -1){
1477
 
    ret_errno = errno;
1478
 
    perror_plus("setuid");
1479
 
  }
1480
 
  errno = old_errno;
1481
 
  return ret_errno;
1482
 
}
1483
 
 
1484
 
bool run_network_hooks(const char *mode, const char *interface,
 
1897
__attribute__((nonnull))
 
1898
void run_network_hooks(const char *mode, const char *interface,
1485
1899
                       const float delay){
1486
 
  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
  }
1487
1932
  struct dirent *direntry;
1488
1933
  int ret;
1489
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1490
 
                         alphasort);
1491
 
  if(numhooks == -1){
1492
 
    if(errno == ENOENT){
1493
 
      if(debug){
1494
 
        fprintf_plus(stderr, "Network hook directory \"%s\" not"
1495
 
                     " found\n", hookdir);
1496
 
      }
1497
 
    } else {
1498
 
      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);
1499
1944
    }
1500
 
  } else {
1501
 
    int devnull = open("/dev/null", O_RDONLY);
1502
 
    for(int i = 0; i < numhooks; i++){
1503
 
      direntry = direntries[i];
1504
 
      char *fullname = NULL;
1505
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1506
 
      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){
1507
1991
        perror_plus("asprintf");
1508
 
        continue;
1509
 
      }
1510
 
      if(debug){
1511
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1512
 
                     direntry->d_name);
1513
 
      }
1514
 
      pid_t hook_pid = fork();
1515
 
      if(hook_pid == 0){
1516
 
        /* Child */
1517
 
        /* Raise privileges */
1518
 
        raise_privileges_permanently();
1519
 
        /* Set group */
1520
 
        errno = 0;
1521
 
        ret = setgid(0);
1522
 
        if(ret == -1){
1523
 
          perror_plus("setgid");
1524
 
        }
1525
 
        /* Reset supplementary groups */
1526
 
        errno = 0;
1527
 
        ret = setgroups(0, NULL);
1528
 
        if(ret == -1){
1529
 
          perror_plus("setgroups");
1530
 
        }
1531
 
        dup2(devnull, STDIN_FILENO);
1532
 
        close(devnull);
1533
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1534
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1535
 
        if(ret == -1){
1536
 
          perror_plus("setenv");
1537
 
          _exit(EX_OSERR);
1538
 
        }
1539
 
        ret = setenv("DEVICE", interface, 1);
1540
 
        if(ret == -1){
1541
 
          perror_plus("setenv");
1542
 
          _exit(EX_OSERR);
1543
 
        }
1544
 
        ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1545
 
        if(ret == -1){
1546
 
          perror_plus("setenv");
1547
 
          _exit(EX_OSERR);
1548
 
        }
1549
 
        ret = setenv("MODE", mode, 1);
1550
 
        if(ret == -1){
1551
 
          perror_plus("setenv");
1552
 
          _exit(EX_OSERR);
1553
 
        }
1554
 
        char *delaystring;
1555
 
        ret = asprintf(&delaystring, "%f", delay);
1556
 
        if(ret == -1){
1557
 
          perror_plus("asprintf");
1558
 
          _exit(EX_OSERR);
1559
 
        }
1560
 
        ret = setenv("DELAY", delaystring, 1);
1561
 
        if(ret == -1){
1562
 
          free(delaystring);
1563
 
          perror_plus("setenv");
1564
 
          _exit(EX_OSERR);
1565
 
        }
 
1992
        _exit(EX_OSERR);
 
1993
      }
 
1994
      ret = setenv("DELAY", delaystring, 1);
 
1995
      if(ret == -1){
1566
1996
        free(delaystring);
1567
 
        if(connect_to != NULL){
1568
 
          ret = setenv("CONNECT", connect_to, 1);
1569
 
          if(ret == -1){
1570
 
            perror_plus("setenv");
1571
 
            _exit(EX_OSERR);
1572
 
          }
1573
 
        }
1574
 
        if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1575
 
          perror_plus("execl");
1576
 
          _exit(EXIT_FAILURE);
1577
 
        }
 
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;
1578
2065
      } else {
1579
 
        int status;
1580
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1581
 
          perror_plus("waitpid");
1582
 
          free(fullname);
1583
 
          continue;
1584
 
        }
1585
 
        if(WIFEXITED(status)){
1586
 
          if(WEXITSTATUS(status) != 0){
1587
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1588
 
                         " with status %d\n", direntry->d_name,
1589
 
                         WEXITSTATUS(status));
1590
 
            free(fullname);
1591
 
            continue;
1592
 
          }
1593
 
        } else if(WIFSIGNALED(status)){
1594
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1595
 
                       " signal %d\n", direntry->d_name,
1596
 
                       WTERMSIG(status));
1597
 
          free(fullname);
1598
 
          continue;
1599
 
        } else {
1600
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1601
 
                       " crashed\n", direntry->d_name);
1602
 
          free(fullname);
1603
 
          continue;
1604
 
        }
1605
 
      }
1606
 
      free(fullname);
1607
 
      if(debug){
1608
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1609
 
                     direntry->d_name);
1610
 
      }
1611
 
    }
1612
 
    close(devnull);
1613
 
  }
1614
 
  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);
1615
2085
}
1616
2086
 
 
2087
__attribute__((nonnull, warn_unused_result))
1617
2088
error_t bring_up_interface(const char *const interface,
1618
2089
                           const float delay){
1619
 
  int sd = -1;
1620
2090
  error_t old_errno = errno;
1621
 
  error_t ret_errno = 0;
1622
 
  int ret, ret_setflags;
 
2091
  int ret;
1623
2092
  struct ifreq network;
1624
2093
  unsigned int if_index = if_nametoindex(interface);
1625
2094
  if(if_index == 0){
1634
2103
  }
1635
2104
  
1636
2105
  if(not interface_is_up(interface)){
1637
 
    if(not get_flags(interface, &network) and debug){
 
2106
    error_t ret_errno = 0, ioctl_errno = 0;
 
2107
    if(not get_flags(interface, &network)){
1638
2108
      ret_errno = errno;
1639
2109
      fprintf_plus(stderr, "Failed to get flags for interface "
1640
2110
                   "\"%s\"\n", interface);
 
2111
      errno = old_errno;
1641
2112
      return ret_errno;
1642
2113
    }
1643
 
    network.ifr_flags |= IFF_UP;
 
2114
    network.ifr_flags |= IFF_UP; /* set flag */
1644
2115
    
1645
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1646
 
    if(sd < 0){
 
2116
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2117
    if(sd == -1){
1647
2118
      ret_errno = errno;
1648
2119
      perror_plus("socket");
1649
2120
      errno = old_errno;
1650
2121
      return ret_errno;
1651
2122
    }
1652
 
  
 
2123
    
1653
2124
    if(quit_now){
1654
 
      close(sd);
 
2125
      ret = close(sd);
 
2126
      if(ret == -1){
 
2127
        perror_plus("close");
 
2128
      }
1655
2129
      errno = old_errno;
1656
2130
      return EINTR;
1657
2131
    }
1661
2135
                   interface);
1662
2136
    }
1663
2137
    
1664
 
    /* Raise priviliges */
1665
 
    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
    }
1666
2144
    
1667
2145
#ifdef __linux__
1668
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1669
 
       messages about the network interface to mess up the prompt */
1670
 
    int ret_linux = klogctl(8, NULL, 5);
1671
 
    bool restore_loglevel = true;
1672
 
    if(ret_linux == -1){
1673
 
      restore_loglevel = false;
1674
 
      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
      }
1675
2157
    }
1676
2158
#endif  /* __linux__ */
1677
 
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1678
 
    ret_errno = errno;
 
2159
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2160
    ioctl_errno = errno;
1679
2161
#ifdef __linux__
1680
2162
    if(restore_loglevel){
1681
2163
      ret_linux = klogctl(7, NULL, 0);
1685
2167
    }
1686
2168
#endif  /* __linux__ */
1687
2169
    
1688
 
    /* Lower privileges */
1689
 
    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
    }
1690
2179
    
1691
2180
    /* Close the socket */
1692
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2181
    ret = close(sd);
1693
2182
    if(ret == -1){
1694
2183
      perror_plus("close");
1695
2184
    }
1696
2185
    
1697
2186
    if(ret_setflags == -1){
1698
 
      errno = ret_errno;
 
2187
      errno = ioctl_errno;
1699
2188
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1700
2189
      errno = old_errno;
1701
 
      return ret_errno;
 
2190
      return ioctl_errno;
1702
2191
    }
1703
2192
  } else if(debug){
1704
2193
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1722
2211
  return 0;
1723
2212
}
1724
2213
 
 
2214
__attribute__((nonnull, warn_unused_result))
1725
2215
error_t take_down_interface(const char *const interface){
1726
 
  int sd = -1;
1727
2216
  error_t old_errno = errno;
1728
 
  error_t ret_errno = 0;
1729
 
  int ret, ret_setflags;
1730
2217
  struct ifreq network;
1731
2218
  unsigned int if_index = if_nametoindex(interface);
1732
2219
  if(if_index == 0){
1735
2222
    return ENXIO;
1736
2223
  }
1737
2224
  if(interface_is_up(interface)){
 
2225
    error_t ret_errno = 0, ioctl_errno = 0;
1738
2226
    if(not get_flags(interface, &network) and debug){
1739
2227
      ret_errno = errno;
1740
2228
      fprintf_plus(stderr, "Failed to get flags for interface "
1741
2229
                   "\"%s\"\n", interface);
 
2230
      errno = old_errno;
1742
2231
      return ret_errno;
1743
2232
    }
1744
2233
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1745
2234
    
1746
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1747
 
    if(sd < 0){
 
2235
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2236
    if(sd == -1){
1748
2237
      ret_errno = errno;
1749
2238
      perror_plus("socket");
1750
2239
      errno = old_errno;
1756
2245
                   interface);
1757
2246
    }
1758
2247
    
1759
 
    /* Raise priviliges */
1760
 
    raise_privileges();
1761
 
    
1762
 
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1763
 
    ret_errno = errno;
1764
 
    
1765
 
    /* Lower privileges */
1766
 
    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
    }
1767
2267
    
1768
2268
    /* Close the socket */
1769
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2269
    int ret = close(sd);
1770
2270
    if(ret == -1){
1771
2271
      perror_plus("close");
1772
2272
    }
1773
2273
    
1774
2274
    if(ret_setflags == -1){
1775
 
      errno = ret_errno;
 
2275
      errno = ioctl_errno;
1776
2276
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1777
2277
      errno = old_errno;
1778
 
      return ret_errno;
 
2278
      return ioctl_errno;
1779
2279
    }
1780
2280
  } else if(debug){
1781
2281
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1787
2287
}
1788
2288
 
1789
2289
int main(int argc, char *argv[]){
1790
 
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
1791
 
                        .priority = "SECURE256:!CTYPE-X.509:"
1792
 
                        "+CTYPE-OPENPGP", .current_server = NULL, 
1793
 
                        .interfaces = NULL, .interfaces_size = 0 };
 
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 };
1794
2295
  AvahiSServiceBrowser *sb = NULL;
1795
2296
  error_t ret_errno;
1796
2297
  int ret;
1799
2300
  int exitcode = EXIT_SUCCESS;
1800
2301
  char *interfaces_to_take_down = NULL;
1801
2302
  size_t interfaces_to_take_down_size = 0;
1802
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1803
 
  bool tempdir_created = false;
 
2303
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2304
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2305
  char *tempdir = NULL;
1804
2306
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1805
2307
  const char *seckey = PATHDIR "/" SECKEY;
1806
2308
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2309
  const char *dh_params_file = NULL;
1807
2310
  char *interfaces_hooks = NULL;
1808
 
  size_t interfaces_hooks_size = 0;
1809
2311
  
1810
2312
  bool gnutls_initialized = false;
1811
2313
  bool gpgme_initialized = false;
1863
2365
        .doc = "Bit length of the prime number used in the"
1864
2366
        " Diffie-Hellman key exchange",
1865
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 },
1866
2373
      { .name = "priority", .key = 130,
1867
2374
        .arg = "STRING",
1868
2375
        .doc = "GnuTLS priority string for the TLS handshake",
1923
2430
        }
1924
2431
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1925
2432
        break;
 
2433
      case 134:                 /* --dh-params */
 
2434
        dh_params_file = arg;
 
2435
        break;
1926
2436
      case 130:                 /* --priority */
1927
2437
        mc.priority = arg;
1928
2438
        break;
1984
2494
      goto end;
1985
2495
    }
1986
2496
  }
1987
 
    
 
2497
  
1988
2498
  {
1989
2499
    /* Work around Debian bug #633582:
1990
2500
       <http://bugs.debian.org/633582> */
1991
2501
    
1992
 
    /* Re-raise priviliges */
1993
 
    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 {
1994
2508
      struct stat st;
1995
2509
      
1996
2510
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2010
2524
              }
2011
2525
            }
2012
2526
          }
2013
 
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2527
          close(seckey_fd);
2014
2528
        }
2015
2529
      }
2016
 
    
 
2530
      
2017
2531
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2018
2532
        int pubkey_fd = open(pubkey, O_RDONLY);
2019
2533
        if(pubkey_fd == -1){
2031
2545
              }
2032
2546
            }
2033
2547
          }
2034
 
          TEMP_FAILURE_RETRY(close(pubkey_fd));
2035
 
        }
2036
 
      }
2037
 
    
 
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
      
2038
2574
      /* Lower privileges */
2039
 
      lower_privileges();
 
2575
      ret_errno = lower_privileges();
 
2576
      if(ret_errno != 0){
 
2577
        errno = ret_errno;
 
2578
        perror_plus("Failed to lower privileges");
 
2579
      }
2040
2580
    }
2041
2581
  }
2042
2582
  
2066
2606
        goto end;
2067
2607
      }
2068
2608
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2069
 
      interfaces_hooks_size = mc.interfaces_size;
2070
 
      argz_stringify(interfaces_hooks, interfaces_hooks_size,
2071
 
                     (int)',');
2072
 
    }
2073
 
    if(not run_network_hooks("start", interfaces_hooks != NULL ?
2074
 
                             interfaces_hooks : "", delay)){
2075
 
      goto end;
2076
 
    }
 
2609
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2610
    }
 
2611
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2612
                      interfaces_hooks : "", delay);
2077
2613
  }
2078
2614
  
2079
2615
  if(not debug){
2157
2693
  
2158
2694
  /* If no interfaces were specified, make a list */
2159
2695
  if(mc.interfaces == NULL){
2160
 
    struct dirent **direntries;
 
2696
    struct dirent **direntries = NULL;
2161
2697
    /* Look for any good interfaces */
2162
2698
    ret = scandir(sys_class_net, &direntries, good_interface,
2163
2699
                  alphasort);
2167
2703
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2168
2704
                             direntries[i]->d_name);
2169
2705
        if(ret_errno != 0){
 
2706
          errno = ret_errno;
2170
2707
          perror_plus("argz_add");
 
2708
          free(direntries[i]);
2171
2709
          continue;
2172
2710
        }
2173
2711
        if(debug){
2174
2712
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
2175
2713
                       direntries[i]->d_name);
2176
2714
        }
 
2715
        free(direntries[i]);
2177
2716
      }
2178
2717
      free(direntries);
2179
2718
    } else {
2180
 
      free(direntries);
 
2719
      if(ret == 0){
 
2720
        free(direntries);
 
2721
      }
2181
2722
      fprintf_plus(stderr, "Could not find a network interface\n");
2182
2723
      exitcode = EXIT_FAILURE;
2183
2724
      goto end;
2206
2747
        break;
2207
2748
      }
2208
2749
      bool interface_was_up = interface_is_up(interface);
2209
 
      ret = bring_up_interface(interface, delay);
 
2750
      errno = bring_up_interface(interface, delay);
2210
2751
      if(not interface_was_up){
2211
 
        if(ret != 0){
2212
 
          errno = ret;
2213
 
          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));
2214
2755
        } else {
2215
 
          ret_errno = argz_add(&interfaces_to_take_down,
2216
 
                               &interfaces_to_take_down_size,
2217
 
                               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
          }
2218
2762
        }
2219
2763
      }
2220
2764
    }
2236
2780
    goto end;
2237
2781
  }
2238
2782
  
2239
 
  ret = init_gnutls_global(pubkey, seckey, &mc);
 
2783
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2240
2784
  if(ret == -1){
2241
2785
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2242
2786
    exitcode = EX_UNAVAILABLE;
2249
2793
    goto end;
2250
2794
  }
2251
2795
  
2252
 
  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){
2253
2806
    perror_plus("mkdtemp");
2254
2807
    goto end;
2255
2808
  }
2256
 
  tempdir_created = true;
2257
2809
  
2258
2810
  if(quit_now){
2259
2811
    goto end;
2334
2886
      sleep((unsigned int)retry_interval);
2335
2887
    }
2336
2888
    
2337
 
    if (not quit_now){
 
2889
    if(not quit_now){
2338
2890
      exitcode = EXIT_SUCCESS;
2339
2891
    }
2340
2892
    
2395
2947
  if(debug){
2396
2948
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2397
2949
  }
2398
 
 
 
2950
  
2399
2951
  ret = avahi_loop_with_timeout(simple_poll,
2400
2952
                                (int)(retry_interval * 1000), &mc);
2401
2953
  if(debug){
2437
2989
    mc.current_server->prev->next = NULL;
2438
2990
    while(mc.current_server != NULL){
2439
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
2440
3000
      free(mc.current_server);
2441
3001
      mc.current_server = next;
2442
3002
    }
2443
3003
  }
2444
3004
  
2445
 
  /* Re-raise priviliges */
 
3005
  /* Re-raise privileges */
2446
3006
  {
2447
 
    raise_privileges();
2448
 
    
2449
 
    /* Run network hooks */
2450
 
    run_network_hooks("stop", interfaces_hooks != NULL ?
2451
 
                      interfaces_hooks : "", delay);
2452
 
    
2453
 
    /* Take down the network interfaces which were brought up */
2454
 
    {
2455
 
      char *interface = NULL;
2456
 
      while((interface=argz_next(interfaces_to_take_down,
2457
 
                                 interfaces_to_take_down_size,
2458
 
                                 interface))){
2459
 
        ret_errno = take_down_interface(interface);
2460
 
        if(ret_errno != 0){
2461
 
          errno = ret_errno;
2462
 
          perror_plus("Failed to take down interface");
2463
 
        }
2464
 
      }
2465
 
      if(debug and (interfaces_to_take_down == NULL)){
2466
 
        fprintf_plus(stderr, "No interfaces needed to be taken"
2467
 
                     " down\n");
2468
 
      }
2469
 
    }
2470
 
    
2471
 
    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
    }
2472
3041
  }
2473
3042
  
2474
3043
  free(interfaces_to_take_down);
2475
3044
  free(interfaces_hooks);
2476
3045
  
2477
3046
  /* Removes the GPGME temp directory and all files inside */
2478
 
  if(tempdir_created){
 
3047
  if(tempdir != NULL){
2479
3048
    struct dirent **direntries = NULL;
2480
 
    struct dirent *direntry = NULL;
2481
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2482
 
                             alphasort);
2483
 
    if (numentries > 0){
2484
 
      for(int i = 0; i < numentries; i++){
2485
 
        direntry = direntries[i];
2486
 
        char *fullname = NULL;
2487
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2488
 
                       direntry->d_name);
2489
 
        if(ret < 0){
2490
 
          perror_plus("asprintf");
2491
 
          continue;
2492
 
        }
2493
 
        ret = remove(fullname);
2494
 
        if(ret == -1){
2495
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2496
 
                       strerror(errno));
2497
 
        }
2498
 
        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
        }
2499
3088
      }
2500
 
    }
2501
 
 
2502
 
    /* need to clean even if 0 because man page doesn't specify */
2503
 
    free(direntries);
2504
 
    if (numentries == -1){
2505
 
      perror_plus("scandir");
2506
 
    }
2507
 
    ret = rmdir(tempdir);
2508
 
    if(ret == -1 and errno != ENOENT){
2509
 
      perror_plus("rmdir");
 
3089
      close(tempdir_fd);
2510
3090
    }
2511
3091
  }
2512
3092