/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

* init.d-mandos: Bug fix: Correct the LSB header.

* mandos.xml (CHECKING): Add text about client disabling requiring
                         manual intervention to reverse.

* plugin-runner.c: Cast return value of TEMP_FAILURE_RETRY to "int"
                   where necessary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
30
30
 */
31
31
 
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
 
33
#ifndef _LARGEFILE_SOURCE
33
34
#define _LARGEFILE_SOURCE
 
35
#endif
 
36
#ifndef _FILE_OFFSET_BITS
34
37
#define _FILE_OFFSET_BITS 64
 
38
#endif
35
39
 
36
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
37
41
 
38
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
39
 
                                   stdout, ferror(), sscanf(),
40
 
                                   remove() */
 
43
                                   stdout, ferror(), remove() */
41
44
#include <stdint.h>             /* uint16_t, uint32_t */
42
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
43
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
44
 
                                   srand() */
 
47
                                   srand(), strtof() */
45
48
#include <stdbool.h>            /* bool, false, true */
46
49
#include <string.h>             /* memset(), strcmp(), strlen(),
47
50
                                   strerror(), asprintf(), strcpy() */
56
59
#include <fcntl.h>              /* open() */
57
60
#include <dirent.h>             /* opendir(), struct dirent, readdir()
58
61
                                 */
59
 
#include <inttypes.h>           /* PRIu16, intmax_t, SCNdMAX */
 
62
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
 
63
                                   strtoimax() */
60
64
#include <assert.h>             /* assert() */
61
65
#include <errno.h>              /* perror(), errno */
62
66
#include <time.h>               /* nanosleep(), time() */
67
71
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
68
72
                                */
69
73
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
70
 
                                   getuid(), getgid(), setuid(),
 
74
                                   getuid(), getgid(), seteuid(),
71
75
                                   setgid() */
72
76
#include <arpa/inet.h>          /* inet_pton(), htons */
73
77
#include <iso646.h>             /* not, or, and */
75
79
                                   argp_state, struct argp,
76
80
                                   argp_parse(), ARGP_KEY_ARG,
77
81
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
78
 
#include <signal.h>             /* sigemptyset(), sigaddset(), sigaction(), SIGTERM, sigaction */
 
82
#include <signal.h>             /* sigemptyset(), sigaddset(),
 
83
                                   sigaction(), SIGTERM, sig_atomic_t,
 
84
                                   raise() */
 
85
 
79
86
#ifdef __linux__
80
87
#include <sys/klog.h>           /* klogctl() */
81
 
#endif
 
88
#endif  /* __linux__ */
82
89
 
83
90
/* Avahi */
84
91
/* All Avahi types, constants and functions
136
143
                      ":!CTYPE-X.509:+CTYPE-OPENPGP" };
137
144
 
138
145
/*
139
 
 * Make additional room in "buffer" for at least BUFFER_SIZE
140
 
 * additional bytes. "buffer_capacity" is how much is currently
141
 
 * allocated, "buffer_length" is how much is already used.
 
146
 * Make additional room in "buffer" for at least BUFFER_SIZE more
 
147
 * bytes. "buffer_capacity" is how much is currently allocated,
 
148
 * "buffer_length" is how much is already used.
142
149
 */
143
150
size_t incbuffer(char **buffer, size_t buffer_length,
144
151
                  size_t buffer_capacity){
157
164
 */
158
165
static bool init_gpgme(const char *seckey,
159
166
                       const char *pubkey, const char *tempdir){
160
 
  int ret;
161
167
  gpgme_error_t rc;
162
168
  gpgme_engine_info_t engine_info;
163
169
  
166
172
   * Helper function to insert pub and seckey to the engine keyring.
167
173
   */
168
174
  bool import_key(const char *filename){
 
175
    int ret;
169
176
    int fd;
170
177
    gpgme_data_t pgp_data;
171
178
    
198
205
  }
199
206
  
200
207
  if(debug){
201
 
    fprintf(stderr, "Initialize gpgme\n");
 
208
    fprintf(stderr, "Initializing GPGME\n");
202
209
  }
203
210
  
204
211
  /* Init GPGME */
242
249
    return false;
243
250
  }
244
251
  
245
 
  return true; 
 
252
  return true;
246
253
}
247
254
 
248
255
/* 
302
309
        }
303
310
        gpgme_recipient_t recipient;
304
311
        recipient = result->recipients;
305
 
        if(recipient){
306
 
          while(recipient != NULL){
307
 
            fprintf(stderr, "Public key algorithm: %s\n",
308
 
                    gpgme_pubkey_algo_name(recipient->pubkey_algo));
309
 
            fprintf(stderr, "Key ID: %s\n", recipient->keyid);
310
 
            fprintf(stderr, "Secret key available: %s\n",
311
 
                    recipient->status == GPG_ERR_NO_SECKEY
312
 
                    ? "No" : "Yes");
313
 
            recipient = recipient->next;
314
 
          }
 
312
        while(recipient != NULL){
 
313
          fprintf(stderr, "Public key algorithm: %s\n",
 
314
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
315
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
316
          fprintf(stderr, "Secret key available: %s\n",
 
317
                  recipient->status == GPG_ERR_NO_SECKEY
 
318
                  ? "No" : "Yes");
 
319
          recipient = recipient->next;
315
320
        }
316
321
      }
317
322
    }
509
514
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
510
515
                      __attribute__((unused)) const char *txt){}
511
516
 
 
517
sig_atomic_t quit_now = 0;
 
518
int signal_received = 0;
 
519
 
512
520
/* Called when a Mandos server is found */
513
521
static int start_mandos_communication(const char *ip, uint16_t port,
514
522
                                      AvahiIfIndex if_index,
515
523
                                      int af){
516
 
  int ret, tcp_sd;
 
524
  int ret, tcp_sd = -1;
517
525
  ssize_t sret;
518
526
  union {
519
527
    struct sockaddr_in in;
523
531
  char *decrypted_buffer;
524
532
  size_t buffer_length = 0;
525
533
  size_t buffer_capacity = 0;
526
 
  ssize_t decrypted_buffer_size;
527
534
  size_t written;
528
535
  int retval = 0;
529
536
  gnutls_session_t session;
530
537
  int pf;                       /* Protocol family */
531
538
  
 
539
  if(quit_now){
 
540
    return -1;
 
541
  }
 
542
  
532
543
  switch(af){
533
544
  case AF_INET6:
534
545
    pf = PF_INET6;
554
565
  tcp_sd = socket(pf, SOCK_STREAM, 0);
555
566
  if(tcp_sd < 0){
556
567
    perror("socket");
557
 
    return -1;
 
568
    retval = -1;
 
569
    goto mandos_end;
 
570
  }
 
571
  
 
572
  if(quit_now){
 
573
    goto mandos_end;
558
574
  }
559
575
  
560
576
  memset(&to, 0, sizeof(to));
561
577
  if(af == AF_INET6){
562
 
    to.in6.sin6_family = (uint16_t)af;
 
578
    to.in6.sin6_family = (sa_family_t)af;
563
579
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
564
580
  } else {                      /* IPv4 */
565
581
    to.in.sin_family = (sa_family_t)af;
567
583
  }
568
584
  if(ret < 0 ){
569
585
    perror("inet_pton");
570
 
    return -1;
 
586
    retval = -1;
 
587
    goto mandos_end;
571
588
  }
572
589
  if(ret == 0){
573
590
    fprintf(stderr, "Bad address: %s\n", ip);
574
 
    return -1;
 
591
    retval = -1;
 
592
    goto mandos_end;
575
593
  }
576
594
  if(af == AF_INET6){
577
595
    to.in6.sin6_port = htons(port); /* Spurious warnings from
584
602
      if(if_index == AVAHI_IF_UNSPEC){
585
603
        fprintf(stderr, "An IPv6 link-local address is incomplete"
586
604
                " without a network interface\n");
587
 
        return -1;
 
605
        retval = -1;
 
606
        goto mandos_end;
588
607
      }
589
608
      /* Set the network interface number as scope */
590
609
      to.in6.sin6_scope_id = (uint32_t)if_index;
595
614
                                     -Wunreachable-code */
596
615
  }
597
616
  
 
617
  if(quit_now){
 
618
    goto mandos_end;
 
619
  }
 
620
  
598
621
  if(debug){
599
622
    if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
600
623
      char interface[IF_NAMESIZE];
627
650
    }
628
651
  }
629
652
  
 
653
  if(quit_now){
 
654
    goto mandos_end;
 
655
  }
 
656
  
630
657
  if(af == AF_INET6){
631
658
    ret = connect(tcp_sd, &to.in6, sizeof(to));
632
659
  } else {
634
661
  }
635
662
  if(ret < 0){
636
663
    perror("connect");
637
 
    return -1;
 
664
    retval = -1;
 
665
    goto mandos_end;
 
666
  }
 
667
  
 
668
  if(quit_now){
 
669
    goto mandos_end;
638
670
  }
639
671
  
640
672
  const char *out = mandos_protocol_version;
659
691
        break;
660
692
      }
661
693
    }
 
694
  
 
695
    if(quit_now){
 
696
      goto mandos_end;
 
697
    }
662
698
  }
663
699
  
664
700
  if(debug){
665
701
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
666
702
  }
667
703
  
 
704
  if(quit_now){
 
705
    goto mandos_end;
 
706
  }
 
707
  
668
708
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
669
709
  
670
 
  do{
 
710
  if(quit_now){
 
711
    goto mandos_end;
 
712
  }
 
713
  
 
714
  do {
671
715
    ret = gnutls_handshake(session);
 
716
    if(quit_now){
 
717
      goto mandos_end;
 
718
    }
672
719
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
673
720
  
674
721
  if(ret != GNUTLS_E_SUCCESS){
688
735
  }
689
736
  
690
737
  while(true){
 
738
    
 
739
    if(quit_now){
 
740
      goto mandos_end;
 
741
    }
 
742
    
691
743
    buffer_capacity = incbuffer(&buffer, buffer_length,
692
744
                                   buffer_capacity);
693
745
    if(buffer_capacity == 0){
696
748
      goto mandos_end;
697
749
    }
698
750
    
 
751
    if(quit_now){
 
752
      goto mandos_end;
 
753
    }
 
754
    
699
755
    sret = gnutls_record_recv(session, buffer+buffer_length,
700
756
                              BUFFER_SIZE);
701
757
    if(sret == 0){
707
763
      case GNUTLS_E_AGAIN:
708
764
        break;
709
765
      case GNUTLS_E_REHANDSHAKE:
710
 
        do{
 
766
        do {
711
767
          ret = gnutls_handshake(session);
 
768
          
 
769
          if(quit_now){
 
770
            goto mandos_end;
 
771
          }
712
772
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
713
773
        if(ret < 0){
714
774
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
733
793
    fprintf(stderr, "Closing TLS session\n");
734
794
  }
735
795
  
 
796
  if(quit_now){
 
797
    goto mandos_end;
 
798
  }
 
799
  
736
800
  gnutls_bye(session, GNUTLS_SHUT_RDWR);
737
801
  
 
802
  if(quit_now){
 
803
    goto mandos_end;
 
804
  }
 
805
  
738
806
  if(buffer_length > 0){
 
807
    ssize_t decrypted_buffer_size;
739
808
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
740
809
                                               buffer_length,
741
810
                                               &decrypted_buffer);
742
811
    if(decrypted_buffer_size >= 0){
 
812
      
743
813
      written = 0;
744
814
      while(written < (size_t) decrypted_buffer_size){
 
815
        if(quit_now){
 
816
          goto mandos_end;
 
817
        }
 
818
        
745
819
        ret = (int)fwrite(decrypted_buffer + written, 1,
746
820
                          (size_t)decrypted_buffer_size - written,
747
821
                          stdout);
767
841
  
768
842
 mandos_end:
769
843
  free(buffer);
770
 
  ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
844
  if(tcp_sd >= 0){
 
845
    ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
846
  }
771
847
  if(ret == -1){
772
848
    perror("close");
773
849
  }
774
850
  gnutls_deinit(session);
 
851
  if(quit_now){
 
852
    retval = -1;
 
853
  }
775
854
  return retval;
776
855
}
777
856
 
788
867
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
789
868
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
790
869
                             flags,
791
 
                             __attribute__((unused)) void* userdata){
 
870
                             AVAHI_GCC_UNUSED void* userdata){
792
871
  assert(r);
793
872
  
794
873
  /* Called whenever a service has been resolved successfully or
795
874
     timed out */
796
875
  
 
876
  if(quit_now){
 
877
    return;
 
878
  }
 
879
  
797
880
  switch(event){
798
881
  default:
799
882
  case AVAHI_RESOLVER_FAILURE:
830
913
                            const char *domain,
831
914
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
832
915
                            flags,
833
 
                            __attribute__((unused)) void* userdata){
 
916
                            AVAHI_GCC_UNUSED void* userdata){
834
917
  assert(b);
835
918
  
836
919
  /* Called whenever a new services becomes available on the LAN or
837
920
     is removed from the LAN */
838
921
  
 
922
  if(quit_now){
 
923
    return;
 
924
  }
 
925
  
839
926
  switch(event){
840
927
  default:
841
928
  case AVAHI_BROWSER_FAILURE:
851
938
       the callback function is called the Avahi server will free the
852
939
       resolver for us. */
853
940
    
854
 
    if(!(avahi_s_service_resolver_new(mc.server, interface,
855
 
                                       protocol, name, type, domain,
856
 
                                       AVAHI_PROTO_INET6, 0,
857
 
                                       resolve_callback, NULL)))
 
941
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
 
942
                                    name, type, domain, protocol, 0,
 
943
                                    resolve_callback, NULL) == NULL)
858
944
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
859
945
              name, avahi_strerror(avahi_server_errno(mc.server)));
860
946
    break;
872
958
}
873
959
 
874
960
/* stop main loop after sigterm has been called */
875
 
static void handle_sigterm(__attribute__((unused)) int sig){
 
961
static void handle_sigterm(int sig){
 
962
  if(quit_now){
 
963
    return;
 
964
  }
 
965
  quit_now = 1;
 
966
  signal_received = sig;
876
967
  int old_errno = errno;
877
 
  avahi_simple_poll_quit(mc.simple_poll);
 
968
  if(mc.simple_poll != NULL){
 
969
    avahi_simple_poll_quit(mc.simple_poll);
 
970
  }
878
971
  errno = old_errno;
879
972
}
880
973
 
883
976
  int error;
884
977
  int ret;
885
978
  intmax_t tmpmax;
886
 
  int numchars;
 
979
  char *tmp;
887
980
  int exitcode = EXIT_SUCCESS;
888
981
  const char *interface = "eth0";
889
982
  struct ifreq network;
890
 
  int sd;
 
983
  int sd = -1;
 
984
  bool take_down_interface = false;
891
985
  uid_t uid;
892
986
  gid_t gid;
893
987
  char *connect_to = NULL;
899
993
  
900
994
  bool gnutls_initialized = false;
901
995
  bool gpgme_initialized = false;
902
 
  double delay = 2.5;
903
 
 
 
996
  float delay = 2.5f;
 
997
  
904
998
  struct sigaction old_sigterm_action;
905
999
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
906
 
 
 
1000
  
907
1001
  {
908
1002
    struct argp_option options[] = {
909
1003
      { .name = "debug", .key = 128,
960
1054
        pubkey = arg;
961
1055
        break;
962
1056
      case 129:                 /* --dh-bits */
963
 
        ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
964
 
        if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
965
 
           or arg[numchars] != '\0'){
 
1057
        errno = 0;
 
1058
        tmpmax = strtoimax(arg, &tmp, 10);
 
1059
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1060
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
966
1061
          fprintf(stderr, "Bad number of DH bits\n");
967
1062
          exit(EXIT_FAILURE);
968
1063
        }
972
1067
        mc.priority = arg;
973
1068
        break;
974
1069
      case 131:                 /* --delay */
975
 
        ret = sscanf(arg, "%lf%n", &delay, &numchars);
976
 
        if(ret < 1 or arg[numchars] != '\0'){
 
1070
        errno = 0;
 
1071
        delay = strtof(arg, &tmp);
 
1072
        if(errno != 0 or tmp == arg or *tmp != '\0'){
977
1073
          fprintf(stderr, "Bad delay\n");
978
1074
          exit(EXIT_FAILURE);
979
1075
        }
999
1095
      goto end;
1000
1096
    }
1001
1097
  }
1002
 
 
 
1098
  
1003
1099
  if(not debug){
1004
1100
    avahi_set_log_function(empty_log);
1005
1101
  }
1006
 
 
 
1102
  
1007
1103
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1008
1104
     from the signal handler */
1009
1105
  /* Initialize the pseudo-RNG for Avahi */
1014
1110
    exitcode = EXIT_FAILURE;
1015
1111
    goto end;
1016
1112
  }
1017
 
 
 
1113
  
1018
1114
  sigemptyset(&sigterm_action.sa_mask);
 
1115
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
 
1116
  if(ret == -1){
 
1117
    perror("sigaddset");
 
1118
    exitcode = EXIT_FAILURE;
 
1119
    goto end;
 
1120
  }
 
1121
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
 
1122
  if(ret == -1){
 
1123
    perror("sigaddset");
 
1124
    exitcode = EXIT_FAILURE;
 
1125
    goto end;
 
1126
  }
1019
1127
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1020
1128
  if(ret == -1){
1021
1129
    perror("sigaddset");
1022
1130
    exitcode = EXIT_FAILURE;
1023
1131
    goto end;
1024
1132
  }
1025
 
  ret = sigaction(SIGTERM, &sigterm_action, &old_sigterm_action);
1026
 
  if(ret == -1){
1027
 
    perror("sigaction");
1028
 
    exitcode = EXIT_FAILURE;
1029
 
    goto end;
1030
 
  }  
1031
 
 
 
1133
  /* Need to check if the handler is SIG_IGN before handling:
 
1134
     | [[info:libc:Initial Signal Actions]] |
 
1135
     | [[info:libc:Basic Signal Handling]]  |
 
1136
  */
 
1137
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
 
1138
  if(ret == -1){
 
1139
    perror("sigaction");
 
1140
    return EXIT_FAILURE;
 
1141
  }
 
1142
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1143
    ret = sigaction(SIGINT, &sigterm_action, NULL);
 
1144
    if(ret == -1){
 
1145
      perror("sigaction");
 
1146
      exitcode = EXIT_FAILURE;
 
1147
      goto end;
 
1148
    }
 
1149
  }
 
1150
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
 
1151
  if(ret == -1){
 
1152
    perror("sigaction");
 
1153
    return EXIT_FAILURE;
 
1154
  }
 
1155
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1156
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
 
1157
    if(ret == -1){
 
1158
      perror("sigaction");
 
1159
      exitcode = EXIT_FAILURE;
 
1160
      goto end;
 
1161
    }
 
1162
  }
 
1163
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
 
1164
  if(ret == -1){
 
1165
    perror("sigaction");
 
1166
    return EXIT_FAILURE;
 
1167
  }
 
1168
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1169
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
 
1170
    if(ret == -1){
 
1171
      perror("sigaction");
 
1172
      exitcode = EXIT_FAILURE;
 
1173
      goto end;
 
1174
    }
 
1175
  }
1032
1176
  
1033
1177
  /* If the interface is down, bring it up */
1034
1178
  if(interface[0] != '\0'){
 
1179
    if_index = (AvahiIfIndex) if_nametoindex(interface);
 
1180
    if(if_index == 0){
 
1181
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
1182
      exitcode = EXIT_FAILURE;
 
1183
      goto end;
 
1184
    }
 
1185
    
 
1186
    if(quit_now){
 
1187
      goto end;
 
1188
    }
 
1189
    
1035
1190
#ifdef __linux__
1036
1191
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1037
1192
       messages to mess up the prompt */
1041
1196
      restore_loglevel = false;
1042
1197
      perror("klogctl");
1043
1198
    }
1044
 
#endif
 
1199
#endif  /* __linux__ */
1045
1200
    
1046
1201
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1047
1202
    if(sd < 0){
1054
1209
          perror("klogctl");
1055
1210
        }
1056
1211
      }
1057
 
#endif
 
1212
#endif  /* __linux__ */
1058
1213
      goto end;
1059
1214
    }
1060
1215
    strcpy(network.ifr_name, interface);
1068
1223
          perror("klogctl");
1069
1224
        }
1070
1225
      }
1071
 
#endif
 
1226
#endif  /* __linux__ */
1072
1227
      exitcode = EXIT_FAILURE;
1073
1228
      goto end;
1074
1229
    }
1075
1230
    if((network.ifr_flags & IFF_UP) == 0){
1076
1231
      network.ifr_flags |= IFF_UP;
 
1232
      take_down_interface = true;
1077
1233
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1078
1234
      if(ret == -1){
 
1235
        take_down_interface = false;
1079
1236
        perror("ioctl SIOCSIFFLAGS");
1080
1237
        exitcode = EXIT_FAILURE;
1081
1238
#ifdef __linux__
1085
1242
            perror("klogctl");
1086
1243
          }
1087
1244
        }
1088
 
#endif
 
1245
#endif  /* __linux__ */
1089
1246
        goto end;
1090
1247
      }
1091
1248
    }
1103
1260
        perror("nanosleep");
1104
1261
      }
1105
1262
    }
1106
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
1107
 
    if(ret == -1){
1108
 
      perror("close");
 
1263
    if(not take_down_interface){
 
1264
      /* We won't need the socket anymore */
 
1265
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1266
      if(ret == -1){
 
1267
        perror("close");
 
1268
      }
1109
1269
    }
1110
1270
#ifdef __linux__
1111
1271
    if(restore_loglevel){
1115
1275
        perror("klogctl");
1116
1276
      }
1117
1277
    }
1118
 
#endif
 
1278
#endif  /* __linux__ */
 
1279
  }
 
1280
  
 
1281
  if(quit_now){
 
1282
    goto end;
1119
1283
  }
1120
1284
  
1121
1285
  uid = getuid();
1122
1286
  gid = getgid();
1123
1287
  
 
1288
  /* Drop any group privileges we might have, just to be safe */
1124
1289
  errno = 0;
1125
 
  setgid(gid);
 
1290
  ret = setgid(gid);
1126
1291
  if(ret == -1){
1127
1292
    perror("setgid");
1128
1293
  }
1129
1294
  
1130
 
  ret = setuid(uid);
1131
 
  if(ret == -1){
1132
 
    perror("setuid");
 
1295
  /* Drop user privileges */
 
1296
  errno = 0;
 
1297
  /* Will we need privileges later? */
 
1298
  if(take_down_interface){
 
1299
    /* Drop user privileges temporarily */
 
1300
    ret = seteuid(uid);
 
1301
    if(ret == -1){
 
1302
      perror("seteuid");
 
1303
    }
 
1304
  } else {
 
1305
    /* Drop user privileges permanently */
 
1306
    ret = setuid(uid);
 
1307
    if(ret == -1){
 
1308
      perror("setuid");
 
1309
    }
 
1310
  }
 
1311
  
 
1312
  if(quit_now){
 
1313
    goto end;
1133
1314
  }
1134
1315
  
1135
1316
  ret = init_gnutls_global(pubkey, seckey);
1141
1322
    gnutls_initialized = true;
1142
1323
  }
1143
1324
  
 
1325
  if(quit_now){
 
1326
    goto end;
 
1327
  }
 
1328
  
 
1329
  tempdir_created = true;
1144
1330
  if(mkdtemp(tempdir) == NULL){
 
1331
    tempdir_created = false;
1145
1332
    perror("mkdtemp");
1146
1333
    goto end;
1147
1334
  }
1148
 
  tempdir_created = true;
 
1335
  
 
1336
  if(quit_now){
 
1337
    goto end;
 
1338
  }
1149
1339
  
1150
1340
  if(not init_gpgme(pubkey, seckey, tempdir)){
1151
1341
    fprintf(stderr, "init_gpgme failed\n");
1155
1345
    gpgme_initialized = true;
1156
1346
  }
1157
1347
  
1158
 
  if(interface[0] != '\0'){
1159
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1160
 
    if(if_index == 0){
1161
 
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
1162
 
      exitcode = EXIT_FAILURE;
1163
 
      goto end;
1164
 
    }
 
1348
  if(quit_now){
 
1349
    goto end;
1165
1350
  }
1166
1351
  
1167
1352
  if(connect_to != NULL){
1173
1358
      exitcode = EXIT_FAILURE;
1174
1359
      goto end;
1175
1360
    }
 
1361
    
 
1362
    if(quit_now){
 
1363
      goto end;
 
1364
    }
 
1365
    
1176
1366
    uint16_t port;
1177
 
    ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1178
 
    if(ret < 1 or tmpmax != (uint16_t)tmpmax
1179
 
       or address[numchars+1] != '\0'){
 
1367
    errno = 0;
 
1368
    tmpmax = strtoimax(address+1, &tmp, 10);
 
1369
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
 
1370
       or tmpmax != (uint16_t)tmpmax){
1180
1371
      fprintf(stderr, "Bad port number\n");
1181
1372
      exitcode = EXIT_FAILURE;
1182
1373
      goto end;
1183
1374
    }
 
1375
  
 
1376
    if(quit_now){
 
1377
      goto end;
 
1378
    }
 
1379
    
1184
1380
    port = (uint16_t)tmpmax;
1185
1381
    *address = '\0';
1186
1382
    address = connect_to;
1191
1387
    } else {
1192
1388
      af = AF_INET;
1193
1389
    }
1194
 
    ret = start_mandos_communication(address, port, if_index,
1195
 
                                     af);
 
1390
    
 
1391
    if(quit_now){
 
1392
      goto end;
 
1393
    }
 
1394
    
 
1395
    ret = start_mandos_communication(address, port, if_index, af);
1196
1396
    if(ret < 0){
1197
1397
      exitcode = EXIT_FAILURE;
1198
1398
    } else {
1200
1400
    }
1201
1401
    goto end;
1202
1402
  }
1203
 
    
 
1403
  
 
1404
  if(quit_now){
 
1405
    goto end;
 
1406
  }
 
1407
  
1204
1408
  {
1205
1409
    AvahiServerConfig config;
1206
1410
    /* Do not publish any local Zeroconf records */
1227
1431
    goto end;
1228
1432
  }
1229
1433
  
 
1434
  if(quit_now){
 
1435
    goto end;
 
1436
  }
 
1437
  
1230
1438
  /* Create the Avahi service browser */
1231
1439
  sb = avahi_s_service_browser_new(mc.server, if_index,
1232
 
                                   AVAHI_PROTO_INET6, "_mandos._tcp",
 
1440
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1233
1441
                                   NULL, 0, browse_callback, NULL);
1234
1442
  if(sb == NULL){
1235
1443
    fprintf(stderr, "Failed to create service browser: %s\n",
1238
1446
    goto end;
1239
1447
  }
1240
1448
  
 
1449
  if(quit_now){
 
1450
    goto end;
 
1451
  }
 
1452
  
1241
1453
  /* Run the main loop */
1242
1454
  
1243
1455
  if(debug){
1272
1484
    gpgme_release(mc.ctx);
1273
1485
  }
1274
1486
  
 
1487
  /* Take down the network interface */
 
1488
  if(take_down_interface){
 
1489
    /* Re-raise priviliges */
 
1490
    errno = 0;
 
1491
    ret = seteuid(0);
 
1492
    if(ret == -1){
 
1493
      perror("seteuid");
 
1494
    }
 
1495
    if(geteuid() == 0){
 
1496
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1497
      if(ret == -1){
 
1498
        perror("ioctl SIOCGIFFLAGS");
 
1499
      } else if(network.ifr_flags & IFF_UP) {
 
1500
        network.ifr_flags &= ~IFF_UP; /* clear flag */
 
1501
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1502
        if(ret == -1){
 
1503
          perror("ioctl SIOCSIFFLAGS");
 
1504
        }
 
1505
      }
 
1506
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1507
      if(ret == -1){
 
1508
        perror("close");
 
1509
      }
 
1510
      /* Lower privileges, permanently this time */
 
1511
      errno = 0;
 
1512
      ret = setuid(uid);
 
1513
      if(ret == -1){
 
1514
        perror("setuid");
 
1515
      }
 
1516
    }
 
1517
  }
 
1518
  
1275
1519
  /* Removes the temp directory used by GPGME */
1276
1520
  if(tempdir_created){
1277
1521
    DIR *d;
1316
1560
    }
1317
1561
  }
1318
1562
  
 
1563
  if(quit_now){
 
1564
    sigemptyset(&old_sigterm_action.sa_mask);
 
1565
    old_sigterm_action.sa_handler = SIG_DFL;
 
1566
    ret = sigaction(signal_received, &old_sigterm_action, NULL);
 
1567
    if(ret == -1){
 
1568
      perror("sigaction");
 
1569
    }
 
1570
    raise(signal_received);
 
1571
  }
 
1572
  
1319
1573
  return exitcode;
1320
1574
}