/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: 2014-07-25 22:44:20 UTC
  • mto: This revision was merged to the branch mainline in revision 724.
  • Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.

This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.

* INSTALL (Prerequisites/Libraries/Mandos Server): Document
                                                   requirement of
                                                   Python 2.7; remove
                                                   Python-argparse
                                                   which is in the
                                                   Python 2.7 standard
                                                   library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
                                                       exactly the
                                                       python2.7
                                                       package and all
                                                       the Python 2.7
                                                       versions of the
                                                       python modules.
  (Package: mandos/Depends): - '' - but still depend on python (<=2.7)
                            and the generic versions of the Python
                            modules; this is for mandos-ctl and
                            mandos-monitor, both of which are
                            compatible with Python 3, and use
                            #!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.

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-2017 Teddy Hogeborn
13
 
 * Copyright © 2008-2017 Björn Påhlsson
14
 
 * 
15
 
 * This file is part of Mandos.
16
 
 * 
17
 
 * Mandos is free software: you can redistribute it and/or modify it
18
 
 * under the terms of the GNU General Public License as published by
19
 
 * the Free Software Foundation, either version 3 of the License, or
20
 
 * (at your option) any later version.
21
 
 * 
22
 
 * Mandos is distributed in the hope that it will be useful, but
 
12
 * Copyright © 2008-2014 Teddy Hogeborn
 
13
 * Copyright © 2008-2014 Björn Påhlsson
 
14
 * 
 
15
 * This program is free software: you can redistribute it and/or
 
16
 * modify it under the terms of the GNU General Public License as
 
17
 * published by the Free Software Foundation, either version 3 of the
 
18
 * License, or (at your option) any later version.
 
19
 * 
 
20
 * This program is distributed in the hope that it will be useful, but
23
21
 * WITHOUT ANY WARRANTY; without even the implied warranty of
24
22
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
23
 * General Public License for more details.
26
24
 * 
27
25
 * You should have received a copy of the GNU General Public License
28
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
26
 * along with this program.  If not, see
 
27
 * <http://www.gnu.org/licenses/>.
29
28
 * 
30
29
 * Contact the authors at <mandos@recompile.se>.
31
30
 */
47
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
48
47
                                   strtof(), abort() */
49
48
#include <stdbool.h>            /* bool, false, true */
50
 
#include <string.h>             /* strcmp(), strlen(), strerror(),
51
 
                                   asprintf(), strncpy(), strsignal()
52
 
                                */
 
49
#include <string.h>             /* memset(), strcmp(), strlen(),
 
50
                                   strerror(), asprintf(), strcpy() */
53
51
#include <sys/ioctl.h>          /* ioctl */
54
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
55
53
                                   sockaddr_in6, PF_INET6,
59
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
60
58
                                   inet_pton(), connect(),
61
59
                                   getnameinfo() */
62
 
#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
63
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
64
62
                                 */
65
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
66
64
                                   strtoimax() */
67
 
#include <errno.h>              /* perror(), errno, EINTR, EINVAL,
68
 
                                   EAI_SYSTEM, ENETUNREACH,
69
 
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
 
                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
 
                                   ENOTEMPTY,
 
65
#include <errno.h>              /* perror(), errno,
72
66
                                   program_invocation_short_name */
73
67
#include <time.h>               /* nanosleep(), time(), sleep() */
74
68
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
311
305
      return false;
312
306
    }
313
307
    
314
 
    ret = close(fd);
 
308
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
315
309
    if(ret == -1){
316
310
      perror_plus("close");
317
311
    }
499
493
  return plaintext_length;
500
494
}
501
495
 
502
 
__attribute__((warn_unused_result, const))
503
 
static const char *safe_string(const char *str){
504
 
  if(str == NULL)
505
 
    return "(unknown)";
506
 
  return str;
507
 
}
508
 
 
509
496
__attribute__((warn_unused_result))
510
497
static const char *safer_gnutls_strerror(int value){
511
498
  const char *ret = gnutls_strerror(value);
512
 
  return safe_string(ret);
 
499
  if(ret == NULL)
 
500
    ret = "(unknown)";
 
501
  return ret;
513
502
}
514
503
 
515
504
/* GnuTLS log function callback */
519
508
  fprintf_plus(stderr, "GnuTLS: %s", string);
520
509
}
521
510
 
522
 
__attribute__((nonnull(1, 2, 4), warn_unused_result))
 
511
__attribute__((nonnull, warn_unused_result))
523
512
static int init_gnutls_global(const char *pubkeyfilename,
524
513
                              const char *seckeyfilename,
525
 
                              const char *dhparamsfilename,
526
514
                              mandos_context *mc){
527
515
  int ret;
528
 
  unsigned int uret;
529
516
  
530
517
  if(debug){
531
518
    fprintf_plus(stderr, "Initializing GnuTLS\n");
532
519
  }
533
520
  
 
521
  ret = gnutls_global_init();
 
522
  if(ret != GNUTLS_E_SUCCESS){
 
523
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
524
                 safer_gnutls_strerror(ret));
 
525
    return -1;
 
526
  }
 
527
  
534
528
  if(debug){
535
529
    /* "Use a log level over 10 to enable all debugging options."
536
530
     * - GnuTLS manual
544
538
  if(ret != GNUTLS_E_SUCCESS){
545
539
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
546
540
                 safer_gnutls_strerror(ret));
 
541
    gnutls_global_deinit();
547
542
    return -1;
548
543
  }
549
544
  
574
569
                 safer_gnutls_strerror(ret));
575
570
    goto globalfail;
576
571
  }
577
 
  /* If a Diffie-Hellman parameters file was given, try to use it */
578
 
  if(dhparamsfilename != NULL){
579
 
    gnutls_datum_t params = { .data = NULL, .size = 0 };
580
 
    do {
581
 
      int dhpfile = open(dhparamsfilename, O_RDONLY);
582
 
      if(dhpfile == -1){
583
 
        perror_plus("open");
584
 
        dhparamsfilename = NULL;
585
 
        break;
586
 
      }
587
 
      size_t params_capacity = 0;
588
 
      while(true){
589
 
        params_capacity = incbuffer((char **)&params.data,
590
 
                                    (size_t)params.size,
591
 
                                    (size_t)params_capacity);
592
 
        if(params_capacity == 0){
593
 
          perror_plus("incbuffer");
594
 
          free(params.data);
595
 
          params.data = NULL;
596
 
          dhparamsfilename = NULL;
597
 
          break;
598
 
        }
599
 
        ssize_t bytes_read = read(dhpfile,
600
 
                                  params.data + params.size,
601
 
                                  BUFFER_SIZE);
602
 
        /* EOF */
603
 
        if(bytes_read == 0){
604
 
          break;
605
 
        }
606
 
        /* check bytes_read for failure */
607
 
        if(bytes_read < 0){
608
 
          perror_plus("read");
609
 
          free(params.data);
610
 
          params.data = NULL;
611
 
          dhparamsfilename = NULL;
612
 
          break;
613
 
        }
614
 
        params.size += (unsigned int)bytes_read;
615
 
      }
616
 
      if(params.data == NULL){
617
 
        dhparamsfilename = NULL;
618
 
      }
619
 
      if(dhparamsfilename == NULL){
620
 
        break;
621
 
      }
622
 
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
623
 
                                          GNUTLS_X509_FMT_PEM);
624
 
      if(ret != GNUTLS_E_SUCCESS){
625
 
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
626
 
                     " \"%s\": %s\n", dhparamsfilename,
627
 
                     safer_gnutls_strerror(ret));
628
 
        dhparamsfilename = NULL;
629
 
      }
630
 
      free(params.data);
631
 
    } while(false);
632
 
  }
633
 
  if(dhparamsfilename == NULL){
634
 
    if(mc->dh_bits == 0){
635
 
      /* Find out the optimal number of DH bits */
636
 
      /* Try to read the private key file */
637
 
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
638
 
      do {
639
 
        int secfile = open(seckeyfilename, O_RDONLY);
640
 
        if(secfile == -1){
641
 
          perror_plus("open");
642
 
          break;
643
 
        }
644
 
        size_t buffer_capacity = 0;
645
 
        while(true){
646
 
          buffer_capacity = incbuffer((char **)&buffer.data,
647
 
                                      (size_t)buffer.size,
648
 
                                      (size_t)buffer_capacity);
649
 
          if(buffer_capacity == 0){
650
 
            perror_plus("incbuffer");
651
 
            free(buffer.data);
652
 
            buffer.data = NULL;
653
 
            break;
654
 
          }
655
 
          ssize_t bytes_read = read(secfile,
656
 
                                    buffer.data + buffer.size,
657
 
                                    BUFFER_SIZE);
658
 
          /* EOF */
659
 
          if(bytes_read == 0){
660
 
            break;
661
 
          }
662
 
          /* check bytes_read for failure */
663
 
          if(bytes_read < 0){
664
 
            perror_plus("read");
665
 
            free(buffer.data);
666
 
            buffer.data = NULL;
667
 
            break;
668
 
          }
669
 
          buffer.size += (unsigned int)bytes_read;
670
 
        }
671
 
        close(secfile);
672
 
      } while(false);
673
 
      /* If successful, use buffer to parse private key */
674
 
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
675
 
      if(buffer.data != NULL){
676
 
        {
677
 
          gnutls_openpgp_privkey_t privkey = NULL;
678
 
          ret = gnutls_openpgp_privkey_init(&privkey);
679
 
          if(ret != GNUTLS_E_SUCCESS){
680
 
            fprintf_plus(stderr, "Error initializing OpenPGP key"
681
 
                         " structure: %s",
682
 
                         safer_gnutls_strerror(ret));
683
 
            free(buffer.data);
684
 
            buffer.data = NULL;
685
 
          } else {
686
 
            ret = gnutls_openpgp_privkey_import
687
 
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
688
 
            if(ret != GNUTLS_E_SUCCESS){
689
 
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
690
 
                           safer_gnutls_strerror(ret));
691
 
              privkey = NULL;
692
 
            }
693
 
            free(buffer.data);
694
 
            buffer.data = NULL;
695
 
            if(privkey != NULL){
696
 
              /* Use private key to suggest an appropriate
697
 
                 sec_param */
698
 
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
699
 
              gnutls_openpgp_privkey_deinit(privkey);
700
 
              if(debug){
701
 
                fprintf_plus(stderr, "This OpenPGP key implies using"
702
 
                             " a GnuTLS security parameter \"%s\".\n",
703
 
                             safe_string(gnutls_sec_param_get_name
704
 
                                         (sec_param)));
705
 
              }
706
 
            }
707
 
          }
708
 
        }
709
 
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
710
 
          /* Err on the side of caution */
711
 
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
712
 
          if(debug){
713
 
            fprintf_plus(stderr, "Falling back to security parameter"
714
 
                         " \"%s\"\n",
715
 
                         safe_string(gnutls_sec_param_get_name
716
 
                                     (sec_param)));
717
 
          }
718
 
        }
719
 
      }
720
 
      uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
721
 
      if(uret != 0){
722
 
        mc->dh_bits = uret;
723
 
        if(debug){
724
 
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
725
 
                       " implies %u DH bits; using that.\n",
726
 
                       safe_string(gnutls_sec_param_get_name
727
 
                                   (sec_param)),
728
 
                       mc->dh_bits);
729
 
        }
730
 
      } else {
731
 
        fprintf_plus(stderr, "Failed to get implied number of DH"
732
 
                     " bits for security parameter \"%s\"): %s\n",
733
 
                     safe_string(gnutls_sec_param_get_name
734
 
                                 (sec_param)),
735
 
                     safer_gnutls_strerror(ret));
736
 
        goto globalfail;
737
 
      }
738
 
    } else if(debug){
739
 
      fprintf_plus(stderr, "DH bits explicitly set to %u\n",
740
 
                   mc->dh_bits);
741
 
    }
742
 
    ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
743
 
    if(ret != GNUTLS_E_SUCCESS){
744
 
      fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
745
 
                   " bits): %s\n", mc->dh_bits,
746
 
                   safer_gnutls_strerror(ret));
747
 
      goto globalfail;
748
 
    }
749
 
  }
 
572
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
573
  if(ret != GNUTLS_E_SUCCESS){
 
574
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
 
575
                 safer_gnutls_strerror(ret));
 
576
    goto globalfail;
 
577
  }
 
578
  
750
579
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
751
580
  
752
581
  return 0;
754
583
 globalfail:
755
584
  
756
585
  gnutls_certificate_free_credentials(mc->cred);
 
586
  gnutls_global_deinit();
757
587
  gnutls_dh_params_deinit(mc->dh_params);
758
588
  return -1;
759
589
}
811
641
  /* ignore client certificate if any. */
812
642
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
813
643
  
 
644
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
 
645
  
814
646
  return 0;
815
647
}
816
648
 
818
650
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
819
651
                      __attribute__((unused)) const char *txt){}
820
652
 
821
 
/* Set effective uid to 0, return errno */
822
 
__attribute__((warn_unused_result))
823
 
int raise_privileges(void){
824
 
  int old_errno = errno;
825
 
  int ret = 0;
826
 
  if(seteuid(0) == -1){
827
 
    ret = errno;
828
 
  }
829
 
  errno = old_errno;
830
 
  return ret;
831
 
}
832
 
 
833
 
/* Set effective and real user ID to 0.  Return errno. */
834
 
__attribute__((warn_unused_result))
835
 
int raise_privileges_permanently(void){
836
 
  int old_errno = errno;
837
 
  int ret = raise_privileges();
838
 
  if(ret != 0){
839
 
    errno = old_errno;
840
 
    return ret;
841
 
  }
842
 
  if(setuid(0) == -1){
843
 
    ret = errno;
844
 
  }
845
 
  errno = old_errno;
846
 
  return ret;
847
 
}
848
 
 
849
 
/* Set effective user ID to unprivileged saved user ID */
850
 
__attribute__((warn_unused_result))
851
 
int lower_privileges(void){
852
 
  int old_errno = errno;
853
 
  int ret = 0;
854
 
  if(seteuid(uid) == -1){
855
 
    ret = errno;
856
 
  }
857
 
  errno = old_errno;
858
 
  return ret;
859
 
}
860
 
 
861
 
/* Lower privileges permanently */
862
 
__attribute__((warn_unused_result))
863
 
int lower_privileges_permanently(void){
864
 
  int old_errno = errno;
865
 
  int ret = 0;
866
 
  if(setuid(uid) == -1){
867
 
    ret = errno;
868
 
  }
869
 
  errno = old_errno;
870
 
  return ret;
871
 
}
872
 
 
873
 
/* Helper function to add_local_route() and delete_local_route() */
874
 
__attribute__((nonnull, warn_unused_result))
875
 
static bool add_delete_local_route(const bool add,
876
 
                                   const char *address,
877
 
                                   AvahiIfIndex if_index){
878
 
  int ret;
879
 
  char helper[] = "mandos-client-iprouteadddel";
880
 
  char add_arg[] = "add";
881
 
  char delete_arg[] = "delete";
882
 
  char debug_flag[] = "--debug";
883
 
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
884
 
  if(pluginhelperdir == NULL){
885
 
    if(debug){
886
 
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
887
 
                   " variable not set; cannot run helper\n");
888
 
    }
889
 
    return false;
890
 
  }
891
 
  
892
 
  char interface[IF_NAMESIZE];
893
 
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
894
 
    perror_plus("if_indextoname");
895
 
    return false;
896
 
  }
897
 
  
898
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
899
 
  if(devnull == -1){
900
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
901
 
    return false;
902
 
  }
903
 
  pid_t pid = fork();
904
 
  if(pid == 0){
905
 
    /* Child */
906
 
    /* Raise privileges */
907
 
    errno = raise_privileges_permanently();
908
 
    if(errno != 0){
909
 
      perror_plus("Failed to raise privileges");
910
 
      /* _exit(EX_NOPERM); */
911
 
    } else {
912
 
      /* Set group */
913
 
      errno = 0;
914
 
      ret = setgid(0);
915
 
      if(ret == -1){
916
 
        perror_plus("setgid");
917
 
        _exit(EX_NOPERM);
918
 
      }
919
 
      /* Reset supplementary groups */
920
 
      errno = 0;
921
 
      ret = setgroups(0, NULL);
922
 
      if(ret == -1){
923
 
        perror_plus("setgroups");
924
 
        _exit(EX_NOPERM);
925
 
      }
926
 
    }
927
 
    ret = dup2(devnull, STDIN_FILENO);
928
 
    if(ret == -1){
929
 
      perror_plus("dup2(devnull, STDIN_FILENO)");
930
 
      _exit(EX_OSERR);
931
 
    }
932
 
    ret = close(devnull);
933
 
    if(ret == -1){
934
 
      perror_plus("close");
935
 
      _exit(EX_OSERR);
936
 
    }
937
 
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
938
 
    if(ret == -1){
939
 
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
940
 
      _exit(EX_OSERR);
941
 
    }
942
 
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
943
 
                                                    O_RDONLY
944
 
                                                    | O_DIRECTORY
945
 
                                                    | O_PATH
946
 
                                                    | O_CLOEXEC));
947
 
    if(helperdir_fd == -1){
948
 
      perror_plus("open");
949
 
      _exit(EX_UNAVAILABLE);
950
 
    }
951
 
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
952
 
                                                   helper, O_RDONLY));
953
 
    if(helper_fd == -1){
954
 
      perror_plus("openat");
955
 
      close(helperdir_fd);
956
 
      _exit(EX_UNAVAILABLE);
957
 
    }
958
 
    close(helperdir_fd);
959
 
#ifdef __GNUC__
960
 
#pragma GCC diagnostic push
961
 
#pragma GCC diagnostic ignored "-Wcast-qual"
962
 
#endif
963
 
    if(fexecve(helper_fd, (char *const [])
964
 
               { helper, add ? add_arg : delete_arg, (char *)address,
965
 
                   interface, debug ? debug_flag : NULL, NULL },
966
 
               environ) == -1){
967
 
#ifdef __GNUC__
968
 
#pragma GCC diagnostic pop
969
 
#endif
970
 
      perror_plus("fexecve");
971
 
      _exit(EXIT_FAILURE);
972
 
    }
973
 
  }
974
 
  if(pid == -1){
975
 
    perror_plus("fork");
976
 
    return false;
977
 
  }
978
 
  int status;
979
 
  pid_t pret = -1;
980
 
  errno = 0;
981
 
  do {
982
 
    pret = waitpid(pid, &status, 0);
983
 
    if(pret == -1 and errno == EINTR and quit_now){
984
 
      int errno_raising = 0;
985
 
      if((errno = raise_privileges()) != 0){
986
 
        errno_raising = errno;
987
 
        perror_plus("Failed to raise privileges in order to"
988
 
                    " kill helper program");
989
 
      }
990
 
      if(kill(pid, SIGTERM) == -1){
991
 
        perror_plus("kill");
992
 
      }
993
 
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
994
 
        perror_plus("Failed to lower privileges after killing"
995
 
                    " helper program");
996
 
      }
997
 
      return false;
998
 
    }
999
 
  } while(pret == -1 and errno == EINTR);
1000
 
  if(pret == -1){
1001
 
    perror_plus("waitpid");
1002
 
    return false;
1003
 
  }
1004
 
  if(WIFEXITED(status)){
1005
 
    if(WEXITSTATUS(status) != 0){
1006
 
      fprintf_plus(stderr, "Error: iprouteadddel exited"
1007
 
                   " with status %d\n", WEXITSTATUS(status));
1008
 
      return false;
1009
 
    }
1010
 
    return true;
1011
 
  }
1012
 
  if(WIFSIGNALED(status)){
1013
 
    fprintf_plus(stderr, "Error: iprouteadddel died by"
1014
 
                 " signal %d\n", WTERMSIG(status));
1015
 
    return false;
1016
 
  }
1017
 
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1018
 
  return false;
1019
 
}
1020
 
 
1021
 
__attribute__((nonnull, warn_unused_result))
1022
 
static bool add_local_route(const char *address,
1023
 
                            AvahiIfIndex if_index){
1024
 
  if(debug){
1025
 
    fprintf_plus(stderr, "Adding route to %s\n", address);
1026
 
  }
1027
 
  return add_delete_local_route(true, address, if_index);
1028
 
}
1029
 
 
1030
 
__attribute__((nonnull, warn_unused_result))
1031
 
static bool delete_local_route(const char *address,
1032
 
                               AvahiIfIndex if_index){
1033
 
  if(debug){
1034
 
    fprintf_plus(stderr, "Removing route to %s\n", address);
1035
 
  }
1036
 
  return add_delete_local_route(false, address, if_index);
1037
 
}
1038
 
 
1039
653
/* Called when a Mandos server is found */
1040
654
__attribute__((nonnull, warn_unused_result))
1041
655
static int start_mandos_communication(const char *ip, in_port_t port,
1052
666
  int retval = -1;
1053
667
  gnutls_session_t session;
1054
668
  int pf;                       /* Protocol family */
1055
 
  bool route_added = false;
1056
669
  
1057
670
  errno = 0;
1058
671
  
1080
693
    bool match = false;
1081
694
    {
1082
695
      char *interface = NULL;
1083
 
      while((interface = argz_next(mc->interfaces,
1084
 
                                   mc->interfaces_size,
1085
 
                                   interface))){
 
696
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
697
                                 interface))){
1086
698
        if(if_nametoindex(interface) == (unsigned int)if_index){
1087
699
          match = true;
1088
700
          break;
1117
729
                 PRIuMAX "\n", ip, (uintmax_t)port);
1118
730
  }
1119
731
  
1120
 
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
 
732
  tcp_sd = socket(pf, SOCK_STREAM, 0);
1121
733
  if(tcp_sd < 0){
1122
734
    int e = errno;
1123
735
    perror_plus("socket");
1130
742
    goto mandos_end;
1131
743
  }
1132
744
  
 
745
  memset(&to, 0, sizeof(to));
1133
746
  if(af == AF_INET6){
1134
 
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1135
 
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1136
 
    ret = inet_pton(af, ip, &to6->sin6_addr);
 
747
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
 
748
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1137
749
  } else {                      /* IPv4 */
1138
 
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1139
 
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1140
 
    ret = inet_pton(af, ip, &to4->sin_addr);
 
750
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
 
751
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1141
752
  }
1142
753
  if(ret < 0 ){
1143
754
    int e = errno;
1213
824
    goto mandos_end;
1214
825
  }
1215
826
  
1216
 
  while(true){
1217
 
    if(af == AF_INET6){
1218
 
      ret = connect(tcp_sd, (struct sockaddr *)&to,
1219
 
                    sizeof(struct sockaddr_in6));
1220
 
    } else {
1221
 
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1222
 
                    sizeof(struct sockaddr_in));
1223
 
    }
1224
 
    if(ret < 0){
1225
 
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1226
 
         and if_index != AVAHI_IF_UNSPEC
1227
 
         and connect_to == NULL
1228
 
         and not route_added and
1229
 
         ((af == AF_INET6 and not
1230
 
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1231
 
                                    &to)->sin6_addr)))
1232
 
          or (af == AF_INET and
1233
 
              /* Not a a IPv4LL address */
1234
 
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1235
 
               & 0xFFFF0000L) != 0xA9FE0000L))){
1236
 
        /* Work around Avahi bug - Avahi does not announce link-local
1237
 
           addresses if it has a global address, so local hosts with
1238
 
           *only* a link-local address (e.g. Mandos clients) cannot
1239
 
           connect to a Mandos server announced by Avahi on a server
1240
 
           host with a global address.  Work around this by retrying
1241
 
           with an explicit route added with the server's address.
1242
 
           
1243
 
           Avahi bug reference:
1244
 
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1245
 
           https://bugs.debian.org/587961
1246
 
        */
1247
 
        if(debug){
1248
 
          fprintf_plus(stderr, "Mandos server unreachable, trying"
1249
 
                       " direct route\n");
1250
 
        }
1251
 
        int e = errno;
1252
 
        route_added = add_local_route(ip, if_index);
1253
 
        if(route_added){
1254
 
          continue;
1255
 
        }
1256
 
        errno = e;
1257
 
      }
1258
 
      if(errno != ECONNREFUSED or debug){
1259
 
        int e = errno;
1260
 
        perror_plus("connect");
1261
 
        errno = e;
1262
 
      }
1263
 
      goto mandos_end;
1264
 
    }
1265
 
    
1266
 
    if(quit_now){
1267
 
      errno = EINTR;
1268
 
      goto mandos_end;
1269
 
    }
1270
 
    break;
 
827
  if(af == AF_INET6){
 
828
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
829
                  sizeof(struct sockaddr_in6));
 
830
  } else {
 
831
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
832
                  sizeof(struct sockaddr_in));
 
833
  }
 
834
  if(ret < 0){
 
835
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
836
      int e = errno;
 
837
      perror_plus("connect");
 
838
      errno = e;
 
839
    }
 
840
    goto mandos_end;
 
841
  }
 
842
  
 
843
  if(quit_now){
 
844
    errno = EINTR;
 
845
    goto mandos_end;
1271
846
  }
1272
847
  
1273
848
  const char *out = mandos_protocol_version;
1427
1002
                                               &decrypted_buffer, mc);
1428
1003
    if(decrypted_buffer_size >= 0){
1429
1004
      
1430
 
      clearerr(stdout);
1431
1005
      written = 0;
1432
1006
      while(written < (size_t) decrypted_buffer_size){
1433
1007
        if(quit_now){
1449
1023
        }
1450
1024
        written += (size_t)ret;
1451
1025
      }
1452
 
      ret = fflush(stdout);
1453
 
      if(ret != 0){
1454
 
        int e = errno;
1455
 
        if(debug){
1456
 
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1457
 
                       strerror(errno));
1458
 
        }
1459
 
        errno = e;
1460
 
        goto mandos_end;
1461
 
      }
1462
1026
      retval = 0;
1463
1027
    }
1464
1028
  }
1467
1031
  
1468
1032
 mandos_end:
1469
1033
  {
1470
 
    if(route_added){
1471
 
      if(not delete_local_route(ip, if_index)){
1472
 
        fprintf_plus(stderr, "Failed to delete local route to %s on"
1473
 
                     " interface %d", ip, if_index);
1474
 
      }
1475
 
    }
1476
1034
    int e = errno;
1477
1035
    free(decrypted_buffer);
1478
1036
    free(buffer);
1479
1037
    if(tcp_sd >= 0){
1480
 
      ret = close(tcp_sd);
 
1038
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1481
1039
    }
1482
1040
    if(ret == -1){
1483
1041
      if(e == 0){
1495
1053
  return retval;
1496
1054
}
1497
1055
 
 
1056
__attribute__((nonnull))
1498
1057
static void resolve_callback(AvahiSServiceResolver *r,
1499
1058
                             AvahiIfIndex interface,
1500
1059
                             AvahiProtocol proto,
1637
1196
__attribute__((nonnull, warn_unused_result))
1638
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1639
1198
  int ret;
1640
 
  int old_errno;
 
1199
  error_t ret_errno;
1641
1200
  
1642
1201
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1643
1202
  if(s < 0){
1644
 
    old_errno = errno;
 
1203
    ret_errno = errno;
1645
1204
    perror_plus("socket");
1646
 
    errno = old_errno;
 
1205
    errno = ret_errno;
1647
1206
    return false;
1648
1207
  }
1649
 
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1650
 
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
 
1208
  strcpy(ifr->ifr_name, ifname);
1651
1209
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1652
1210
  if(ret == -1){
1653
1211
    if(debug){
1654
 
      old_errno = errno;
 
1212
      ret_errno = errno;
1655
1213
      perror_plus("ioctl SIOCGIFFLAGS");
1656
 
      errno = old_errno;
 
1214
      errno = ret_errno;
1657
1215
    }
1658
1216
    return false;
1659
1217
  }
1904
1462
  }
1905
1463
}
1906
1464
 
 
1465
/* Set effective uid to 0, return errno */
 
1466
__attribute__((warn_unused_result))
 
1467
error_t raise_privileges(void){
 
1468
  error_t old_errno = errno;
 
1469
  error_t ret_errno = 0;
 
1470
  if(seteuid(0) == -1){
 
1471
    ret_errno = errno;
 
1472
  }
 
1473
  errno = old_errno;
 
1474
  return ret_errno;
 
1475
}
 
1476
 
 
1477
/* Set effective and real user ID to 0.  Return errno. */
 
1478
__attribute__((warn_unused_result))
 
1479
error_t raise_privileges_permanently(void){
 
1480
  error_t old_errno = errno;
 
1481
  error_t ret_errno = raise_privileges();
 
1482
  if(ret_errno != 0){
 
1483
    errno = old_errno;
 
1484
    return ret_errno;
 
1485
  }
 
1486
  if(setuid(0) == -1){
 
1487
    ret_errno = errno;
 
1488
  }
 
1489
  errno = old_errno;
 
1490
  return ret_errno;
 
1491
}
 
1492
 
 
1493
/* Set effective user ID to unprivileged saved user ID */
 
1494
__attribute__((warn_unused_result))
 
1495
error_t lower_privileges(void){
 
1496
  error_t old_errno = errno;
 
1497
  error_t ret_errno = 0;
 
1498
  if(seteuid(uid) == -1){
 
1499
    ret_errno = errno;
 
1500
  }
 
1501
  errno = old_errno;
 
1502
  return ret_errno;
 
1503
}
 
1504
 
 
1505
/* Lower privileges permanently */
 
1506
__attribute__((warn_unused_result))
 
1507
error_t lower_privileges_permanently(void){
 
1508
  error_t old_errno = errno;
 
1509
  error_t ret_errno = 0;
 
1510
  if(setuid(uid) == -1){
 
1511
    ret_errno = errno;
 
1512
  }
 
1513
  errno = old_errno;
 
1514
  return ret_errno;
 
1515
}
 
1516
 
1907
1517
__attribute__((nonnull))
1908
1518
void run_network_hooks(const char *mode, const char *interface,
1909
1519
                       const float delay){
1910
1520
  struct dirent **direntries = NULL;
1911
1521
  if(hookdir_fd == -1){
1912
 
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1913
 
                      | O_CLOEXEC);
 
1522
    hookdir_fd = open(hookdir, O_RDONLY);
1914
1523
    if(hookdir_fd == -1){
1915
1524
      if(errno == ENOENT){
1916
1525
        if(debug){
1923
1532
      return;
1924
1533
    }
1925
1534
  }
 
1535
#ifdef __GLIBC__
 
1536
#if __GLIBC_PREREQ(2, 15)
1926
1537
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
1927
1538
                           runnable_hook, alphasort);
 
1539
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1540
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1541
                         alphasort);
 
1542
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1543
#else   /* not __GLIBC__ */
 
1544
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1545
                         alphasort);
 
1546
#endif  /* not __GLIBC__ */
1928
1547
  if(numhooks == -1){
1929
1548
    perror_plus("scandir");
1930
1549
    return;
1931
1550
  }
1932
1551
  struct dirent *direntry;
1933
1552
  int ret;
1934
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1935
 
  if(devnull == -1){
1936
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
1937
 
    return;
1938
 
  }
 
1553
  int devnull = open("/dev/null", O_RDONLY);
1939
1554
  for(int i = 0; i < numhooks; i++){
1940
1555
    direntry = direntries[i];
1941
1556
    if(debug){
1965
1580
        perror_plus("setgroups");
1966
1581
        _exit(EX_NOPERM);
1967
1582
      }
 
1583
      ret = dup2(devnull, STDIN_FILENO);
 
1584
      if(ret == -1){
 
1585
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
1586
        _exit(EX_OSERR);
 
1587
      }
 
1588
      ret = close(devnull);
 
1589
      if(ret == -1){
 
1590
        perror_plus("close");
 
1591
        _exit(EX_OSERR);
 
1592
      }
 
1593
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1594
      if(ret == -1){
 
1595
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1596
        _exit(EX_OSERR);
 
1597
      }
1968
1598
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1969
1599
      if(ret == -1){
1970
1600
        perror_plus("setenv");
2005
1635
          _exit(EX_OSERR);
2006
1636
        }
2007
1637
      }
2008
 
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2009
 
                                                   direntry->d_name,
2010
 
                                                   O_RDONLY));
 
1638
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2011
1639
      if(hook_fd == -1){
2012
1640
        perror_plus("openat");
2013
1641
        _exit(EXIT_FAILURE);
2014
1642
      }
2015
 
      if(close(hookdir_fd) == -1){
 
1643
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2016
1644
        perror_plus("close");
2017
1645
        _exit(EXIT_FAILURE);
2018
1646
      }
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
1647
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2035
1648
                 environ) == -1){
2036
1649
        perror_plus("fexecve");
2037
1650
        _exit(EXIT_FAILURE);
2038
1651
      }
2039
1652
    } else {
2040
 
      if(hook_pid == -1){
2041
 
        perror_plus("fork");
2042
 
        free(direntry);
2043
 
        continue;
2044
 
      }
2045
1653
      int status;
2046
1654
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2047
1655
        perror_plus("waitpid");
2076
1684
    free(direntry);
2077
1685
  }
2078
1686
  free(direntries);
2079
 
  if(close(hookdir_fd) == -1){
 
1687
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2080
1688
    perror_plus("close");
2081
1689
  } else {
2082
1690
    hookdir_fd = -1;
2085
1693
}
2086
1694
 
2087
1695
__attribute__((nonnull, warn_unused_result))
2088
 
int bring_up_interface(const char *const interface,
2089
 
                       const float delay){
2090
 
  int old_errno = errno;
 
1696
error_t bring_up_interface(const char *const interface,
 
1697
                           const float delay){
 
1698
  error_t old_errno = errno;
2091
1699
  int ret;
2092
1700
  struct ifreq network;
2093
1701
  unsigned int if_index = if_nametoindex(interface);
2103
1711
  }
2104
1712
  
2105
1713
  if(not interface_is_up(interface)){
2106
 
    int ret_errno = 0;
2107
 
    int ioctl_errno = 0;
 
1714
    error_t ret_errno = 0, ioctl_errno = 0;
2108
1715
    if(not get_flags(interface, &network)){
2109
1716
      ret_errno = errno;
2110
1717
      fprintf_plus(stderr, "Failed to get flags for interface "
2123
1730
    }
2124
1731
    
2125
1732
    if(quit_now){
2126
 
      ret = close(sd);
 
1733
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2127
1734
      if(ret == -1){
2128
1735
        perror_plus("close");
2129
1736
      }
2179
1786
    }
2180
1787
    
2181
1788
    /* Close the socket */
2182
 
    ret = close(sd);
 
1789
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
2183
1790
    if(ret == -1){
2184
1791
      perror_plus("close");
2185
1792
    }
2197
1804
  
2198
1805
  /* Sleep checking until interface is running.
2199
1806
     Check every 0.25s, up to total time of delay */
2200
 
  for(int i = 0; i < delay * 4; i++){
 
1807
  for(int i=0; i < delay * 4; i++){
2201
1808
    if(interface_is_running(interface)){
2202
1809
      break;
2203
1810
    }
2213
1820
}
2214
1821
 
2215
1822
__attribute__((nonnull, warn_unused_result))
2216
 
int take_down_interface(const char *const interface){
2217
 
  int old_errno = errno;
 
1823
error_t take_down_interface(const char *const interface){
 
1824
  error_t old_errno = errno;
2218
1825
  struct ifreq network;
2219
1826
  unsigned int if_index = if_nametoindex(interface);
2220
1827
  if(if_index == 0){
2223
1830
    return ENXIO;
2224
1831
  }
2225
1832
  if(interface_is_up(interface)){
2226
 
    int ret_errno = 0;
2227
 
    int ioctl_errno = 0;
 
1833
    error_t ret_errno = 0, ioctl_errno = 0;
2228
1834
    if(not get_flags(interface, &network) and debug){
2229
1835
      ret_errno = errno;
2230
1836
      fprintf_plus(stderr, "Failed to get flags for interface "
2268
1874
    }
2269
1875
    
2270
1876
    /* Close the socket */
2271
 
    int ret = close(sd);
 
1877
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2272
1878
    if(ret == -1){
2273
1879
      perror_plus("close");
2274
1880
    }
2289
1895
}
2290
1896
 
2291
1897
int main(int argc, char *argv[]){
2292
 
  mandos_context mc = { .server = NULL, .dh_bits = 0,
2293
 
                        .priority = "SECURE256:!CTYPE-X.509"
2294
 
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2295
 
                        .current_server = NULL, .interfaces = NULL,
2296
 
                        .interfaces_size = 0 };
 
1898
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
 
1899
                        .priority = "SECURE256:!CTYPE-X.509:"
 
1900
                        "+CTYPE-OPENPGP", .current_server = NULL,
 
1901
                        .interfaces = NULL, .interfaces_size = 0 };
2297
1902
  AvahiSServiceBrowser *sb = NULL;
2298
1903
  error_t ret_errno;
2299
1904
  int ret;
2308
1913
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2309
1914
  const char *seckey = PATHDIR "/" SECKEY;
2310
1915
  const char *pubkey = PATHDIR "/" PUBKEY;
2311
 
  const char *dh_params_file = NULL;
2312
1916
  char *interfaces_hooks = NULL;
2313
1917
  
2314
1918
  bool gnutls_initialized = false;
2367
1971
        .doc = "Bit length of the prime number used in the"
2368
1972
        " Diffie-Hellman key exchange",
2369
1973
        .group = 2 },
2370
 
      { .name = "dh-params", .key = 134,
2371
 
        .arg = "FILE",
2372
 
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2373
 
        " for the Diffie-Hellman key exchange",
2374
 
        .group = 2 },
2375
1974
      { .name = "priority", .key = 130,
2376
1975
        .arg = "STRING",
2377
1976
        .doc = "GnuTLS priority string for the TLS handshake",
2432
2031
        }
2433
2032
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2434
2033
        break;
2435
 
      case 134:                 /* --dh-params */
2436
 
        dh_params_file = arg;
2437
 
        break;
2438
2034
      case 130:                 /* --priority */
2439
2035
        mc.priority = arg;
2440
2036
        break;
2480
2076
                         .args_doc = "",
2481
2077
                         .doc = "Mandos client -- Get and decrypt"
2482
2078
                         " passwords from a Mandos server" };
2483
 
    ret_errno = argp_parse(&argp, argc, argv,
2484
 
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2485
 
    switch(ret_errno){
 
2079
    ret = argp_parse(&argp, argc, argv,
 
2080
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2081
    switch(ret){
2486
2082
    case 0:
2487
2083
      break;
2488
2084
    case ENOMEM:
2489
2085
    default:
2490
 
      errno = ret_errno;
 
2086
      errno = ret;
2491
2087
      perror_plus("argp_parse");
2492
2088
      exitcode = EX_OSERR;
2493
2089
      goto end;
2496
2092
      goto end;
2497
2093
    }
2498
2094
  }
2499
 
  
 
2095
    
2500
2096
  {
2501
2097
    /* Work around Debian bug #633582:
2502
 
       <https://bugs.debian.org/633582> */
 
2098
       <http://bugs.debian.org/633582> */
2503
2099
    
2504
2100
    /* Re-raise privileges */
2505
 
    ret = raise_privileges();
2506
 
    if(ret != 0){
2507
 
      errno = ret;
 
2101
    ret_errno = raise_privileges();
 
2102
    if(ret_errno != 0){
 
2103
      errno = ret_errno;
2508
2104
      perror_plus("Failed to raise privileges");
2509
2105
    } else {
2510
2106
      struct stat st;
2526
2122
              }
2527
2123
            }
2528
2124
          }
2529
 
          close(seckey_fd);
 
2125
          TEMP_FAILURE_RETRY(close(seckey_fd));
2530
2126
        }
2531
2127
      }
2532
 
      
 
2128
    
2533
2129
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2534
2130
        int pubkey_fd = open(pubkey, O_RDONLY);
2535
2131
        if(pubkey_fd == -1){
2547
2143
              }
2548
2144
            }
2549
2145
          }
2550
 
          close(pubkey_fd);
2551
 
        }
2552
 
      }
2553
 
      
2554
 
      if(dh_params_file != NULL
2555
 
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2556
 
        int dhparams_fd = open(dh_params_file, O_RDONLY);
2557
 
        if(dhparams_fd == -1){
2558
 
          perror_plus("open");
2559
 
        } else {
2560
 
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2561
 
          if(ret == -1){
2562
 
            perror_plus("fstat");
2563
 
          } else {
2564
 
            if(S_ISREG(st.st_mode)
2565
 
               and st.st_uid == 0 and st.st_gid == 0){
2566
 
              ret = fchown(dhparams_fd, uid, gid);
2567
 
              if(ret == -1){
2568
 
                perror_plus("fchown");
2569
 
              }
2570
 
            }
2571
 
          }
2572
 
          close(dhparams_fd);
2573
 
        }
2574
 
      }
2575
 
      
 
2146
          TEMP_FAILURE_RETRY(close(pubkey_fd));
 
2147
        }
 
2148
      }
 
2149
    
2576
2150
      /* Lower privileges */
2577
 
      ret = lower_privileges();
2578
 
      if(ret != 0){
2579
 
        errno = ret;
 
2151
      ret_errno = lower_privileges();
 
2152
      if(ret_errno != 0){
 
2153
        errno = ret_errno;
2580
2154
        perror_plus("Failed to lower privileges");
2581
2155
      }
2582
2156
    }
2752
2326
      errno = bring_up_interface(interface, delay);
2753
2327
      if(not interface_was_up){
2754
2328
        if(errno != 0){
2755
 
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2756
 
                       " %s\n", interface, strerror(errno));
 
2329
          perror_plus("Failed to bring up interface");
2757
2330
        } else {
2758
2331
          errno = argz_add(&interfaces_to_take_down,
2759
2332
                           &interfaces_to_take_down_size,
2782
2355
    goto end;
2783
2356
  }
2784
2357
  
2785
 
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
 
2358
  ret = init_gnutls_global(pubkey, seckey, &mc);
2786
2359
  if(ret == -1){
2787
2360
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2788
2361
    exitcode = EX_UNAVAILABLE;
2910
2483
    
2911
2484
    /* Allocate a new server */
2912
2485
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2913
 
                                 &config, NULL, NULL, &ret);
 
2486
                                 &config, NULL, NULL, &ret_errno);
2914
2487
    
2915
2488
    /* Free the Avahi configuration data */
2916
2489
    avahi_server_config_free(&config);
2919
2492
  /* Check if creating the Avahi server object succeeded */
2920
2493
  if(mc.server == NULL){
2921
2494
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2922
 
                 avahi_strerror(ret));
 
2495
                 avahi_strerror(ret_errno));
2923
2496
    exitcode = EX_UNAVAILABLE;
2924
2497
    goto end;
2925
2498
  }
2960
2533
 end:
2961
2534
  
2962
2535
  if(debug){
2963
 
    if(signal_received){
2964
 
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
2965
 
                   argv[0], signal_received,
2966
 
                   strsignal(signal_received));
2967
 
    } else {
2968
 
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
2969
 
    }
 
2536
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
2970
2537
  }
2971
2538
  
2972
2539
  /* Cleanup things */
2983
2550
  
2984
2551
  if(gnutls_initialized){
2985
2552
    gnutls_certificate_free_credentials(mc.cred);
 
2553
    gnutls_global_deinit();
2986
2554
    gnutls_dh_params_deinit(mc.dh_params);
2987
2555
  }
2988
2556
  
3011
2579
  
3012
2580
  /* Re-raise privileges */
3013
2581
  {
3014
 
    ret = raise_privileges();
3015
 
    if(ret != 0){
3016
 
      errno = ret;
 
2582
    ret_errno = raise_privileges();
 
2583
    if(ret_errno != 0){
 
2584
      errno = ret_errno;
3017
2585
      perror_plus("Failed to raise privileges");
3018
2586
    } else {
3019
2587
      
3024
2592
      /* Take down the network interfaces which were brought up */
3025
2593
      {
3026
2594
        char *interface = NULL;
3027
 
        while((interface = argz_next(interfaces_to_take_down,
3028
 
                                     interfaces_to_take_down_size,
3029
 
                                     interface))){
3030
 
          ret = take_down_interface(interface);
3031
 
          if(ret != 0){
3032
 
            errno = ret;
 
2595
        while((interface=argz_next(interfaces_to_take_down,
 
2596
                                   interfaces_to_take_down_size,
 
2597
                                   interface))){
 
2598
          ret_errno = take_down_interface(interface);
 
2599
          if(ret_errno != 0){
 
2600
            errno = ret_errno;
3033
2601
            perror_plus("Failed to take down interface");
3034
2602
          }
3035
2603
        }
3040
2608
      }
3041
2609
    }
3042
2610
    
3043
 
    ret = lower_privileges_permanently();
3044
 
    if(ret != 0){
3045
 
      errno = ret;
 
2611
    ret_errno = lower_privileges_permanently();
 
2612
    if(ret_errno != 0){
 
2613
      errno = ret_errno;
3046
2614
      perror_plus("Failed to lower privileges permanently");
3047
2615
    }
3048
2616
  }
3050
2618
  free(interfaces_to_take_down);
3051
2619
  free(interfaces_hooks);
3052
2620
  
3053
 
  void clean_dir_at(int base, const char * const dirname,
3054
 
                    uintmax_t level){
3055
 
    struct dirent **direntries = NULL;
3056
 
    int dret;
3057
 
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3058
 
                                                O_RDONLY
3059
 
                                                | O_NOFOLLOW
3060
 
                                                | O_DIRECTORY
3061
 
                                                | O_PATH));
3062
 
    if(dir_fd == -1){
3063
 
      perror_plus("open");
3064
 
    }
3065
 
    int numentries = scandirat(dir_fd, ".", &direntries,
3066
 
                               notdotentries, alphasort);
3067
 
    if(numentries >= 0){
3068
 
      for(int i = 0; i < numentries; i++){
3069
 
        if(debug){
3070
 
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3071
 
                       dirname, direntries[i]->d_name);
3072
 
        }
3073
 
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3074
 
        if(dret == -1){
3075
 
          if(errno == EISDIR){
3076
 
              dret = unlinkat(dir_fd, direntries[i]->d_name,
3077
 
                              AT_REMOVEDIR);
3078
 
          }         
3079
 
          if((dret == -1) and (errno == ENOTEMPTY)
3080
 
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3081
 
                  == 0) and (level == 0)){
3082
 
            /* Recurse only in this special case */
3083
 
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3084
 
            dret = 0;
3085
 
          }
3086
 
          if(dret == -1){
3087
 
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3088
 
                         direntries[i]->d_name, strerror(errno));
3089
 
          }
3090
 
        }
3091
 
        free(direntries[i]);
3092
 
      }
3093
 
      
3094
 
      /* need to clean even if 0 because man page doesn't specify */
3095
 
      free(direntries);
3096
 
      if(numentries == -1){
3097
 
        perror_plus("scandirat");
3098
 
      }
3099
 
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
3100
 
      if(dret == -1 and errno != ENOENT){
3101
 
        perror_plus("rmdir");
3102
 
      }
3103
 
    } else {
3104
 
      perror_plus("scandirat");
3105
 
    }
3106
 
    close(dir_fd);
3107
 
  }
3108
 
  
3109
2621
  /* Removes the GPGME temp directory and all files inside */
3110
2622
  if(tempdir != NULL){
3111
 
    clean_dir_at(-1, tempdir, 0);
 
2623
    struct dirent **direntries = NULL;
 
2624
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
 
2625
                                                  O_NOFOLLOW));
 
2626
    if(tempdir_fd == -1){
 
2627
      perror_plus("open");
 
2628
    } else {
 
2629
#ifdef __GLIBC__
 
2630
#if __GLIBC_PREREQ(2, 15)
 
2631
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
2632
                                 notdotentries, alphasort);
 
2633
#else  /* not __GLIBC_PREREQ(2, 15) */
 
2634
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2635
                               alphasort);
 
2636
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
2637
#else   /* not __GLIBC__ */
 
2638
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2639
                               alphasort);
 
2640
#endif  /* not __GLIBC__ */
 
2641
      if(numentries >= 0){
 
2642
        for(int i = 0; i < numentries; i++){
 
2643
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
2644
          if(ret == -1){
 
2645
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
2646
                         " \"%s\", 0): %s\n", tempdir,
 
2647
                         direntries[i]->d_name, strerror(errno));
 
2648
          }
 
2649
          free(direntries[i]);
 
2650
        }
 
2651
        
 
2652
        /* need to clean even if 0 because man page doesn't specify */
 
2653
        free(direntries);
 
2654
        if(numentries == -1){
 
2655
          perror_plus("scandir");
 
2656
        }
 
2657
        ret = rmdir(tempdir);
 
2658
        if(ret == -1 and errno != ENOENT){
 
2659
          perror_plus("rmdir");
 
2660
        }
 
2661
      }
 
2662
      TEMP_FAILURE_RETRY(close(tempdir_fd));
 
2663
    }
3112
2664
  }
3113
2665
  
3114
2666
  if(quit_now){