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
- browse files at revision 749.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 749.1.1
- Committer: Teddy Hogeborn
- Date: 2015-05-23 20:18:34 UTC
- mto: This revision was merged to the branch mainline in revision 756.
- Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2018 Teddy Hogeborn
13
* Copyright © 2008-2018 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
}
519
513
fprintf_plus(stderr, "GnuTLS: %s", string);
520
514
}
521
515
522
__attribute__((nonnull(1, 2, 4), warn_unused_result))
516
__attribute__((nonnull, warn_unused_result))
523
517
static int init_gnutls_global(const char *pubkeyfilename,
524
518
const char *seckeyfilename,
525
const char *dhparamsfilename,
526
519
mandos_context *mc){
527
520
int ret;
528
521
unsigned int uret;
531
524
fprintf_plus(stderr, "Initializing GnuTLS\n");
532
525
}
533
526
527
ret = gnutls_global_init();
528
if(ret != GNUTLS_E_SUCCESS){
529
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
530
safer_gnutls_strerror(ret));
531
return -1;
532
}
533
534
534
if(debug){
535
535
/* "Use a log level over 10 to enable all debugging options."
536
536
* - GnuTLS manual
544
544
if(ret != GNUTLS_E_SUCCESS){
545
545
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
546
546
safer_gnutls_strerror(ret));
547
gnutls_global_deinit();
547
548
return -1;
548
549
}
549
550
574
575
safer_gnutls_strerror(ret));
575
576
goto globalfail;
576
577
}
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;
578
if(mc->dh_bits == 0){
579
/* Find out the optimal number of DH bits */
580
/* Try to read the private key file */
581
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
582
{
583
int secfile = open(seckeyfilename, O_RDONLY);
584
size_t buffer_capacity = 0;
588
585
while(true){
589
params_capacity = incbuffer((char **)¶ms.data,
590
(size_t)params.size,
591
(size_t)params_capacity);
592
if(params_capacity == 0){
586
buffer_capacity = incbuffer((char **)&buffer.data,
587
(size_t)buffer.size,
588
(size_t)buffer_capacity);
589
if(buffer_capacity == 0){
593
590
perror_plus("incbuffer");
594
free(params.data);
595
params.data = NULL;
596
dhparamsfilename = NULL;
591
free(buffer.data);
592
buffer.data = NULL;
597
593
break;
598
594
}
599
ssize_t bytes_read = read(dhpfile,
600
params.data + params.size,
595
ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
601
596
BUFFER_SIZE);
602
597
/* EOF */
603
598
if(bytes_read == 0){
606
601
/* check bytes_read for failure */
607
602
if(bytes_read < 0){
608
603
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, ¶ms,
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);
604
free(buffer.data);
605
buffer.data = NULL;
606
break;
607
}
608
buffer.size += (unsigned int)bytes_read;
609
}
610
close(secfile);
611
}
612
/* If successful, use buffer to parse private key */
613
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
614
if(buffer.data != NULL){
615
{
616
gnutls_openpgp_privkey_t privkey = NULL;
617
ret = gnutls_openpgp_privkey_init(&privkey);
618
if(ret != GNUTLS_E_SUCCESS){
619
fprintf_plus(stderr, "Error initializing OpenPGP key"
620
" structure: %s", safer_gnutls_strerror(ret));
621
free(buffer.data);
622
buffer.data = NULL;
623
} else {
624
ret = gnutls_openpgp_privkey_import(privkey, &buffer,
625
GNUTLS_OPENPGP_FMT_BASE64,
626
"", 0);
679
627
if(ret != GNUTLS_E_SUCCESS){
680
fprintf_plus(stderr, "Error initializing OpenPGP key"
681
" structure: %s",
628
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
682
629
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
}
630
privkey = NULL;
707
631
}
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)));
632
free(buffer.data);
633
buffer.data = NULL;
634
if(privkey != NULL){
635
/* Use private key to suggest an appropriate sec_param */
636
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
637
gnutls_openpgp_privkey_deinit(privkey);
638
if(debug){
639
fprintf_plus(stderr, "This OpenPGP key implies using a"
640
" GnuTLS security parameter \"%s\".\n",
641
safe_string(gnutls_sec_param_get_name
642
(sec_param)));
643
}
717
644
}
718
645
}
719
646
}
720
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
721
if(uret != 0){
722
mc->dh_bits = uret;
647
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
648
/* Err on the side of caution */
649
sec_param = GNUTLS_SEC_PARAM_ULTRA;
723
650
if(debug){
724
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
725
" implies %u DH bits; using that.\n",
651
fprintf_plus(stderr, "Falling back to security parameter"
652
" \"%s\"\n",
726
653
safe_string(gnutls_sec_param_get_name
727
(sec_param)),
728
mc->dh_bits);
654
(sec_param)));
729
655
}
730
} else {
731
fprintf_plus(stderr, "Failed to get implied number of DH"
732
" bits for security parameter \"%s\"): %s\n",
656
}
657
}
658
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
659
if(uret != 0){
660
mc->dh_bits = uret;
661
if(debug){
662
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
663
" implies %u DH bits; using that.\n",
733
664
safe_string(gnutls_sec_param_get_name
734
665
(sec_param)),
735
safer_gnutls_strerror(ret));
736
goto globalfail;
666
mc->dh_bits);
737
667
}
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,
668
} else {
669
fprintf_plus(stderr, "Failed to get implied number of DH"
670
" bits for security parameter \"%s\"): %s\n",
671
safe_string(gnutls_sec_param_get_name(sec_param)),
746
672
safer_gnutls_strerror(ret));
747
673
goto globalfail;
748
674
}
749
}
675
} else if(debug){
676
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
677
mc->dh_bits);
678
}
679
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
680
if(ret != GNUTLS_E_SUCCESS){
681
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
682
" %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
683
goto globalfail;
684
}
685
750
686
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
751
687
752
688
return 0;
754
690
globalfail:
755
691
756
692
gnutls_certificate_free_credentials(mc->cred);
693
gnutls_global_deinit();
757
694
gnutls_dh_params_deinit(mc->dh_params);
758
695
return -1;
759
696
}
811
748
/* ignore client certificate if any. */
812
749
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
813
750
751
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
752
814
753
return 0;
815
754
}
816
755
818
757
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
819
758
__attribute__((unused)) const char *txt){}
820
759
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
760
/* Called when a Mandos server is found */
1040
761
__attribute__((nonnull, warn_unused_result))
1041
762
static int start_mandos_communication(const char *ip, in_port_t port,
1052
773
int retval = -1;
1053
774
gnutls_session_t session;
1054
775
int pf; /* Protocol family */
1055
bool route_added = false;
1056
776
1057
777
errno = 0;
1058
778
1080
800
bool match = false;
1081
801
{
1082
802
char *interface = NULL;
1083
while((interface = argz_next(mc->interfaces,
1084
mc->interfaces_size,
1085
interface))){
803
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
804
interface))){
1086
805
if(if_nametoindex(interface) == (unsigned int)if_index){
1087
806
match = true;
1088
807
break;
1117
836
PRIuMAX "\n", ip, (uintmax_t)port);
1118
837
}
1119
838
1120
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
839
tcp_sd = socket(pf, SOCK_STREAM, 0);
1121
840
if(tcp_sd < 0){
1122
841
int e = errno;
1123
842
perror_plus("socket");
1130
849
goto mandos_end;
1131
850
}
1132
851
852
memset(&to, 0, sizeof(to));
1133
853
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);
854
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
855
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1137
856
} 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);
857
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
858
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1141
859
}
1142
860
if(ret < 0 ){
1143
861
int e = errno;
1213
931
goto mandos_end;
1214
932
}
1215
933
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;
934
if(af == AF_INET6){
935
ret = connect(tcp_sd, (struct sockaddr *)&to,
936
sizeof(struct sockaddr_in6));
937
} else {
938
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
939
sizeof(struct sockaddr_in));
940
}
941
if(ret < 0){
942
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
943
int e = errno;
944
perror_plus("connect");
945
errno = e;
946
}
947
goto mandos_end;
948
}
949
950
if(quit_now){
951
errno = EINTR;
952
goto mandos_end;
1271
953
}
1272
954
1273
955
const char *out = mandos_protocol_version;
1427
1109
&decrypted_buffer, mc);
1428
1110
if(decrypted_buffer_size >= 0){
1429
1111
1430
clearerr(stdout);
1431
1112
written = 0;
1432
1113
while(written < (size_t) decrypted_buffer_size){
1433
1114
if(quit_now){
1449
1130
}
1450
1131
written += (size_t)ret;
1451
1132
}
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
1133
retval = 0;
1463
1134
}
1464
1135
}
1467
1138
1468
1139
mandos_end:
1469
1140
{
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
1141
int e = errno;
1477
1142
free(decrypted_buffer);
1478
1143
free(buffer);
1479
1144
if(tcp_sd >= 0){
1480
ret = close(tcp_sd);
1145
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1481
1146
}
1482
1147
if(ret == -1){
1483
1148
if(e == 0){
1495
1160
return retval;
1496
1161
}
1497
1162
1163
__attribute__((nonnull))
1498
1164
static void resolve_callback(AvahiSServiceResolver *r,
1499
1165
AvahiIfIndex interface,
1500
1166
AvahiProtocol proto,
1637
1303
__attribute__((nonnull, warn_unused_result))
1638
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1639
1305
int ret;
1640
int old_errno;
1306
error_t ret_errno;
1641
1307
1642
1308
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1643
1309
if(s < 0){
1644
old_errno = errno;
1310
ret_errno = errno;
1645
1311
perror_plus("socket");
1646
errno = old_errno;
1312
errno = ret_errno;
1647
1313
return false;
1648
1314
}
1649
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1650
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1315
strcpy(ifr->ifr_name, ifname);
1651
1316
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1652
1317
if(ret == -1){
1653
1318
if(debug){
1654
old_errno = errno;
1319
ret_errno = errno;
1655
1320
perror_plus("ioctl SIOCGIFFLAGS");
1656
errno = old_errno;
1321
errno = ret_errno;
1657
1322
}
1658
1323
return false;
1659
1324
}
1904
1569
}
1905
1570
}
1906
1571
1572
/* Set effective uid to 0, return errno */
1573
__attribute__((warn_unused_result))
1574
error_t raise_privileges(void){
1575
error_t old_errno = errno;
1576
error_t ret_errno = 0;
1577
if(seteuid(0) == -1){
1578
ret_errno = errno;
1579
}
1580
errno = old_errno;
1581
return ret_errno;
1582
}
1583
1584
/* Set effective and real user ID to 0. Return errno. */
1585
__attribute__((warn_unused_result))
1586
error_t raise_privileges_permanently(void){
1587
error_t old_errno = errno;
1588
error_t ret_errno = raise_privileges();
1589
if(ret_errno != 0){
1590
errno = old_errno;
1591
return ret_errno;
1592
}
1593
if(setuid(0) == -1){
1594
ret_errno = errno;
1595
}
1596
errno = old_errno;
1597
return ret_errno;
1598
}
1599
1600
/* Set effective user ID to unprivileged saved user ID */
1601
__attribute__((warn_unused_result))
1602
error_t lower_privileges(void){
1603
error_t old_errno = errno;
1604
error_t ret_errno = 0;
1605
if(seteuid(uid) == -1){
1606
ret_errno = errno;
1607
}
1608
errno = old_errno;
1609
return ret_errno;
1610
}
1611
1612
/* Lower privileges permanently */
1613
__attribute__((warn_unused_result))
1614
error_t lower_privileges_permanently(void){
1615
error_t old_errno = errno;
1616
error_t ret_errno = 0;
1617
if(setuid(uid) == -1){
1618
ret_errno = errno;
1619
}
1620
errno = old_errno;
1621
return ret_errno;
1622
}
1623
1907
1624
__attribute__((nonnull))
1908
1625
void run_network_hooks(const char *mode, const char *interface,
1909
1626
const float delay){
1910
1627
struct dirent **direntries = NULL;
1911
1628
if(hookdir_fd == -1){
1912
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1913
| O_CLOEXEC);
1629
hookdir_fd = open(hookdir, O_RDONLY);
1914
1630
if(hookdir_fd == -1){
1915
1631
if(errno == ENOENT){
1916
1632
if(debug){
1923
1639
return;
1924
1640
}
1925
1641
}
1926
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1927
if(devnull == -1){
1928
perror_plus("open(\"/dev/null\", O_RDONLY)");
1929
return;
1930
}
1642
#ifdef __GLIBC__
1643
#if __GLIBC_PREREQ(2, 15)
1931
1644
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1932
1645
runnable_hook, alphasort);
1646
#else /* not __GLIBC_PREREQ(2, 15) */
1647
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1648
alphasort);
1649
#endif /* not __GLIBC_PREREQ(2, 15) */
1650
#else /* not __GLIBC__ */
1651
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1652
alphasort);
1653
#endif /* not __GLIBC__ */
1933
1654
if(numhooks == -1){
1934
1655
perror_plus("scandir");
1935
close(devnull);
1936
1656
return;
1937
1657
}
1938
1658
struct dirent *direntry;
1939
1659
int ret;
1660
int devnull = open("/dev/null", O_RDONLY);
1940
1661
for(int i = 0; i < numhooks; i++){
1941
1662
direntry = direntries[i];
1942
1663
if(debug){
1966
1687
perror_plus("setgroups");
1967
1688
_exit(EX_NOPERM);
1968
1689
}
1690
ret = dup2(devnull, STDIN_FILENO);
1691
if(ret == -1){
1692
perror_plus("dup2(devnull, STDIN_FILENO)");
1693
_exit(EX_OSERR);
1694
}
1695
ret = close(devnull);
1696
if(ret == -1){
1697
perror_plus("close");
1698
_exit(EX_OSERR);
1699
}
1700
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1701
if(ret == -1){
1702
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1703
_exit(EX_OSERR);
1704
}
1969
1705
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1970
1706
if(ret == -1){
1971
1707
perror_plus("setenv");
2006
1742
_exit(EX_OSERR);
2007
1743
}
2008
1744
}
2009
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2010
direntry->d_name,
2011
O_RDONLY));
1745
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2012
1746
if(hook_fd == -1){
2013
1747
perror_plus("openat");
2014
1748
_exit(EXIT_FAILURE);
2015
1749
}
2016
if(close(hookdir_fd) == -1){
1750
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2017
1751
perror_plus("close");
2018
1752
_exit(EXIT_FAILURE);
2019
1753
}
2020
ret = dup2(devnull, STDIN_FILENO);
2021
if(ret == -1){
2022
perror_plus("dup2(devnull, STDIN_FILENO)");
2023
_exit(EX_OSERR);
2024
}
2025
ret = close(devnull);
2026
if(ret == -1){
2027
perror_plus("close");
2028
_exit(EX_OSERR);
2029
}
2030
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2031
if(ret == -1){
2032
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2033
_exit(EX_OSERR);
2034
}
2035
1754
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2036
1755
environ) == -1){
2037
1756
perror_plus("fexecve");
2077
1796
free(direntry);
2078
1797
}
2079
1798
free(direntries);
2080
if(close(hookdir_fd) == -1){
1799
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2081
1800
perror_plus("close");
2082
1801
} else {
2083
1802
hookdir_fd = -1;
2086
1805
}
2087
1806
2088
1807
__attribute__((nonnull, warn_unused_result))
2089
int bring_up_interface(const char *const interface,
2090
const float delay){
2091
int old_errno = errno;
1808
error_t bring_up_interface(const char *const interface,
1809
const float delay){
1810
error_t old_errno = errno;
2092
1811
int ret;
2093
1812
struct ifreq network;
2094
1813
unsigned int if_index = if_nametoindex(interface);
2104
1823
}
2105
1824
2106
1825
if(not interface_is_up(interface)){
2107
int ret_errno = 0;
2108
int ioctl_errno = 0;
1826
error_t ret_errno = 0, ioctl_errno = 0;
2109
1827
if(not get_flags(interface, &network)){
2110
1828
ret_errno = errno;
2111
1829
fprintf_plus(stderr, "Failed to get flags for interface "
2124
1842
}
2125
1843
2126
1844
if(quit_now){
2127
ret = close(sd);
1845
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2128
1846
if(ret == -1){
2129
1847
perror_plus("close");
2130
1848
}
2180
1898
}
2181
1899
2182
1900
/* Close the socket */
2183
ret = close(sd);
1901
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2184
1902
if(ret == -1){
2185
1903
perror_plus("close");
2186
1904
}
2198
1916
2199
1917
/* Sleep checking until interface is running.
2200
1918
Check every 0.25s, up to total time of delay */
2201
for(int i = 0; i < delay * 4; i++){
1919
for(int i=0; i < delay * 4; i++){
2202
1920
if(interface_is_running(interface)){
2203
1921
break;
2204
1922
}
2214
1932
}
2215
1933
2216
1934
__attribute__((nonnull, warn_unused_result))
2217
int take_down_interface(const char *const interface){
2218
int old_errno = errno;
1935
error_t take_down_interface(const char *const interface){
1936
error_t old_errno = errno;
2219
1937
struct ifreq network;
2220
1938
unsigned int if_index = if_nametoindex(interface);
2221
1939
if(if_index == 0){
2224
1942
return ENXIO;
2225
1943
}
2226
1944
if(interface_is_up(interface)){
2227
int ret_errno = 0;
2228
int ioctl_errno = 0;
1945
error_t ret_errno = 0, ioctl_errno = 0;
2229
1946
if(not get_flags(interface, &network) and debug){
2230
1947
ret_errno = errno;
2231
1948
fprintf_plus(stderr, "Failed to get flags for interface "
2269
1986
}
2270
1987
2271
1988
/* Close the socket */
2272
int ret = close(sd);
1989
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2273
1990
if(ret == -1){
2274
1991
perror_plus("close");
2275
1992
}
2291
2008
2292
2009
int main(int argc, char *argv[]){
2293
2010
mandos_context mc = { .server = NULL, .dh_bits = 0,
2294
.priority = "SECURE256:!CTYPE-X.509"
2295
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2296
.current_server = NULL, .interfaces = NULL,
2297
.interfaces_size = 0 };
2011
.priority = "SECURE256:!CTYPE-X.509:"
2012
"+CTYPE-OPENPGP:!RSA", .current_server = NULL,
2013
.interfaces = NULL, .interfaces_size = 0 };
2298
2014
AvahiSServiceBrowser *sb = NULL;
2299
2015
error_t ret_errno;
2300
2016
int ret;
2309
2025
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2310
2026
const char *seckey = PATHDIR "/" SECKEY;
2311
2027
const char *pubkey = PATHDIR "/" PUBKEY;
2312
const char *dh_params_file = NULL;
2313
2028
char *interfaces_hooks = NULL;
2314
2029
2315
2030
bool gnutls_initialized = false;
2368
2083
.doc = "Bit length of the prime number used in the"
2369
2084
" Diffie-Hellman key exchange",
2370
2085
.group = 2 },
2371
{ .name = "dh-params", .key = 134,
2372
.arg = "FILE",
2373
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2374
" for the Diffie-Hellman key exchange",
2375
.group = 2 },
2376
2086
{ .name = "priority", .key = 130,
2377
2087
.arg = "STRING",
2378
2088
.doc = "GnuTLS priority string for the TLS handshake",
2433
2143
}
2434
2144
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2435
2145
break;
2436
case 134: /* --dh-params */
2437
dh_params_file = arg;
2438
break;
2439
2146
case 130: /* --priority */
2440
2147
mc.priority = arg;
2441
2148
break;
2481
2188
.args_doc = "",
2482
2189
.doc = "Mandos client -- Get and decrypt"
2483
2190
" passwords from a Mandos server" };
2484
ret_errno = argp_parse(&argp, argc, argv,
2485
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2486
switch(ret_errno){
2191
ret = argp_parse(&argp, argc, argv,
2192
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2193
switch(ret){
2487
2194
case 0:
2488
2195
break;
2489
2196
case ENOMEM:
2490
2197
default:
2491
errno = ret_errno;
2198
errno = ret;
2492
2199
perror_plus("argp_parse");
2493
2200
exitcode = EX_OSERR;
2494
2201
goto end;
2497
2204
goto end;
2498
2205
}
2499
2206
}
2500
2207
2501
2208
{
2502
2209
/* Work around Debian bug #633582:
2503
<https://bugs.debian.org/633582> */
2210
<http://bugs.debian.org/633582> */
2504
2211
2505
2212
/* Re-raise privileges */
2506
ret = raise_privileges();
2507
if(ret != 0){
2508
errno = ret;
2213
ret_errno = raise_privileges();
2214
if(ret_errno != 0){
2215
errno = ret_errno;
2509
2216
perror_plus("Failed to raise privileges");
2510
2217
} else {
2511
2218
struct stat st;
2527
2234
}
2528
2235
}
2529
2236
}
2530
close(seckey_fd);
2237
TEMP_FAILURE_RETRY(close(seckey_fd));
2531
2238
}
2532
2239
}
2533
2240
2534
2241
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2535
2242
int pubkey_fd = open(pubkey, O_RDONLY);
2536
2243
if(pubkey_fd == -1){
2548
2255
}
2549
2256
}
2550
2257
}
2551
close(pubkey_fd);
2552
}
2553
}
2554
2555
if(dh_params_file != NULL
2556
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2557
int dhparams_fd = open(dh_params_file, O_RDONLY);
2558
if(dhparams_fd == -1){
2559
perror_plus("open");
2560
} else {
2561
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2562
if(ret == -1){
2563
perror_plus("fstat");
2564
} else {
2565
if(S_ISREG(st.st_mode)
2566
and st.st_uid == 0 and st.st_gid == 0){
2567
ret = fchown(dhparams_fd, uid, gid);
2568
if(ret == -1){
2569
perror_plus("fchown");
2570
}
2571
}
2572
}
2573
close(dhparams_fd);
2574
}
2575
}
2576
2258
TEMP_FAILURE_RETRY(close(pubkey_fd));
2259
}
2260
}
2261
2577
2262
/* Lower privileges */
2578
ret = lower_privileges();
2579
if(ret != 0){
2580
errno = ret;
2263
ret_errno = lower_privileges();
2264
if(ret_errno != 0){
2265
errno = ret_errno;
2581
2266
perror_plus("Failed to lower privileges");
2582
2267
}
2583
2268
}
2753
2438
errno = bring_up_interface(interface, delay);
2754
2439
if(not interface_was_up){
2755
2440
if(errno != 0){
2756
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2757
" %s\n", interface, strerror(errno));
2441
perror_plus("Failed to bring up interface");
2758
2442
} else {
2759
2443
errno = argz_add(&interfaces_to_take_down,
2760
2444
&interfaces_to_take_down_size,
2783
2467
goto end;
2784
2468
}
2785
2469
2786
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2470
ret = init_gnutls_global(pubkey, seckey, &mc);
2787
2471
if(ret == -1){
2788
2472
fprintf_plus(stderr, "init_gnutls_global failed\n");
2789
2473
exitcode = EX_UNAVAILABLE;
2911
2595
2912
2596
/* Allocate a new server */
2913
2597
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2914
&config, NULL, NULL, &ret);
2598
&config, NULL, NULL, &ret_errno);
2915
2599
2916
2600
/* Free the Avahi configuration data */
2917
2601
avahi_server_config_free(&config);
2920
2604
/* Check if creating the Avahi server object succeeded */
2921
2605
if(mc.server == NULL){
2922
2606
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2923
avahi_strerror(ret));
2607
avahi_strerror(ret_errno));
2924
2608
exitcode = EX_UNAVAILABLE;
2925
2609
goto end;
2926
2610
}
2961
2645
end:
2962
2646
2963
2647
if(debug){
2964
if(signal_received){
2965
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
2966
argv[0], signal_received,
2967
strsignal(signal_received));
2968
} else {
2969
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2970
}
2648
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2971
2649
}
2972
2650
2973
2651
/* Cleanup things */
2984
2662
2985
2663
if(gnutls_initialized){
2986
2664
gnutls_certificate_free_credentials(mc.cred);
2665
gnutls_global_deinit();
2987
2666
gnutls_dh_params_deinit(mc.dh_params);
2988
2667
}
2989
2668
3012
2691
3013
2692
/* Re-raise privileges */
3014
2693
{
3015
ret = raise_privileges();
3016
if(ret != 0){
3017
errno = ret;
2694
ret_errno = raise_privileges();
2695
if(ret_errno != 0){
2696
errno = ret_errno;
3018
2697
perror_plus("Failed to raise privileges");
3019
2698
} else {
3020
2699
3025
2704
/* Take down the network interfaces which were brought up */
3026
2705
{
3027
2706
char *interface = NULL;
3028
while((interface = argz_next(interfaces_to_take_down,
3029
interfaces_to_take_down_size,
3030
interface))){
3031
ret = take_down_interface(interface);
3032
if(ret != 0){
3033
errno = ret;
2707
while((interface=argz_next(interfaces_to_take_down,
2708
interfaces_to_take_down_size,
2709
interface))){
2710
ret_errno = take_down_interface(interface);
2711
if(ret_errno != 0){
2712
errno = ret_errno;
3034
2713
perror_plus("Failed to take down interface");
3035
2714
}
3036
2715
}
3041
2720
}
3042
2721
}
3043
2722
3044
ret = lower_privileges_permanently();
3045
if(ret != 0){
3046
errno = ret;
2723
ret_errno = lower_privileges_permanently();
2724
if(ret_errno != 0){
2725
errno = ret_errno;
3047
2726
perror_plus("Failed to lower privileges permanently");
3048
2727
}
3049
2728
}
3051
2730
free(interfaces_to_take_down);
3052
2731
free(interfaces_hooks);
3053
2732
3054
void clean_dir_at(int base, const char * const dirname,
3055
uintmax_t level){
3056
struct dirent **direntries = NULL;
3057
int dret;
3058
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3059
O_RDONLY
3060
| O_NOFOLLOW
3061
| O_DIRECTORY
3062
| O_PATH));
3063
if(dir_fd == -1){
3064
perror_plus("open");
3065
return;
3066
}
3067
int numentries = scandirat(dir_fd, ".", &direntries,
3068
notdotentries, alphasort);
3069
if(numentries >= 0){
3070
for(int i = 0; i < numentries; i++){
3071
if(debug){
3072
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3073
dirname, direntries[i]->d_name);
3074
}
3075
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3076
if(dret == -1){
3077
if(errno == EISDIR){
3078
dret = unlinkat(dir_fd, direntries[i]->d_name,
3079
AT_REMOVEDIR);
3080
}
3081
if((dret == -1) and (errno == ENOTEMPTY)
3082
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3083
== 0) and (level == 0)){
3084
/* Recurse only in this special case */
3085
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3086
dret = 0;
3087
}
3088
if((dret == -1) and (errno != ENOENT)){
3089
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3090
direntries[i]->d_name, strerror(errno));
3091
}
3092
}
3093
free(direntries[i]);
3094
}
3095
3096
/* need to clean even if 0 because man page doesn't specify */
3097
free(direntries);
3098
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3099
if(dret == -1 and errno != ENOENT){
3100
perror_plus("rmdir");
3101
}
3102
} else {
3103
perror_plus("scandirat");
3104
}
3105
close(dir_fd);
3106
}
3107
3108
2733
/* Removes the GPGME temp directory and all files inside */
3109
2734
if(tempdir != NULL){
3110
clean_dir_at(-1, tempdir, 0);
2735
struct dirent **direntries = NULL;
2736
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2737
O_NOFOLLOW));
2738
if(tempdir_fd == -1){
2739
perror_plus("open");
2740
} else {
2741
#ifdef __GLIBC__
2742
#if __GLIBC_PREREQ(2, 15)
2743
int numentries = scandirat(tempdir_fd, ".", &direntries,
2744
notdotentries, alphasort);
2745
#else /* not __GLIBC_PREREQ(2, 15) */
2746
int numentries = scandir(tempdir, &direntries, notdotentries,
2747
alphasort);
2748
#endif /* not __GLIBC_PREREQ(2, 15) */
2749
#else /* not __GLIBC__ */
2750
int numentries = scandir(tempdir, &direntries, notdotentries,
2751
alphasort);
2752
#endif /* not __GLIBC__ */
2753
if(numentries >= 0){
2754
for(int i = 0; i < numentries; i++){
2755
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2756
if(ret == -1){
2757
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2758
" \"%s\", 0): %s\n", tempdir,
2759
direntries[i]->d_name, strerror(errno));
2760
}
2761
free(direntries[i]);
2762
}
2763
2764
/* need to clean even if 0 because man page doesn't specify */
2765
free(direntries);
2766
if(numentries == -1){
2767
perror_plus("scandir");
2768
}
2769
ret = rmdir(tempdir);
2770
if(ret == -1 and errno != ENOENT){
2771
perror_plus("rmdir");
2772
}
2773
}
2774
TEMP_FAILURE_RETRY(close(tempdir_fd));
2775
}
3111
2776
}
3112
2777
3113
2778
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0