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 723.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 723.1.1
- 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.
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.
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
}
420
414
if(result == NULL){
421
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
422
416
} else {
423
if(result->unsupported_algorithm != NULL) {
424
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
425
result->unsupported_algorithm);
426
}
427
fprintf_plus(stderr, "Wrong key usage: %s\n",
428
result->wrong_key_usage ? "Yes" : "No");
417
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
418
result->unsupported_algorithm);
419
fprintf_plus(stderr, "Wrong key usage: %u\n",
420
result->wrong_key_usage);
429
421
if(result->file_name != NULL){
430
422
fprintf_plus(stderr, "File name: %s\n", result->file_name);
431
423
}
501
493
return plaintext_length;
502
494
}
503
495
504
__attribute__((warn_unused_result, const))
505
static const char *safe_string(const char *str){
506
if(str == NULL)
507
return "(unknown)";
508
return str;
509
}
510
511
496
__attribute__((warn_unused_result))
512
497
static const char *safer_gnutls_strerror(int value){
513
498
const char *ret = gnutls_strerror(value);
514
return safe_string(ret);
499
if(ret == NULL)
500
ret = "(unknown)";
501
return ret;
515
502
}
516
503
517
504
/* GnuTLS log function callback */
521
508
fprintf_plus(stderr, "GnuTLS: %s", string);
522
509
}
523
510
524
__attribute__((nonnull(1, 2, 4), warn_unused_result))
511
__attribute__((nonnull, warn_unused_result))
525
512
static int init_gnutls_global(const char *pubkeyfilename,
526
513
const char *seckeyfilename,
527
const char *dhparamsfilename,
528
514
mandos_context *mc){
529
515
int ret;
530
unsigned int uret;
531
516
532
517
if(debug){
533
518
fprintf_plus(stderr, "Initializing GnuTLS\n");
534
519
}
535
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
536
528
if(debug){
537
529
/* "Use a log level over 10 to enable all debugging options."
538
530
* - GnuTLS manual
546
538
if(ret != GNUTLS_E_SUCCESS){
547
539
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
548
540
safer_gnutls_strerror(ret));
541
gnutls_global_deinit();
549
542
return -1;
550
543
}
551
544
576
569
safer_gnutls_strerror(ret));
577
570
goto globalfail;
578
571
}
579
/* If a Diffie-Hellman parameters file was given, try to use it */
580
if(dhparamsfilename != NULL){
581
gnutls_datum_t params = { .data = NULL, .size = 0 };
582
do {
583
int dhpfile = open(dhparamsfilename, O_RDONLY);
584
if(dhpfile == -1){
585
perror_plus("open");
586
dhparamsfilename = NULL;
587
break;
588
}
589
size_t params_capacity = 0;
590
while(true){
591
params_capacity = incbuffer((char **)¶ms.data,
592
(size_t)params.size,
593
(size_t)params_capacity);
594
if(params_capacity == 0){
595
perror_plus("incbuffer");
596
free(params.data);
597
params.data = NULL;
598
dhparamsfilename = NULL;
599
break;
600
}
601
ssize_t bytes_read = read(dhpfile,
602
params.data + params.size,
603
BUFFER_SIZE);
604
/* EOF */
605
if(bytes_read == 0){
606
break;
607
}
608
/* check bytes_read for failure */
609
if(bytes_read < 0){
610
perror_plus("read");
611
free(params.data);
612
params.data = NULL;
613
dhparamsfilename = NULL;
614
break;
615
}
616
params.size += (unsigned int)bytes_read;
617
}
618
ret = close(dhpfile);
619
if(ret == -1){
620
perror_plus("close");
621
}
622
if(params.data == NULL){
623
dhparamsfilename = NULL;
624
}
625
if(dhparamsfilename == NULL){
626
break;
627
}
628
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
629
GNUTLS_X509_FMT_PEM);
630
if(ret != GNUTLS_E_SUCCESS){
631
fprintf_plus(stderr, "Failed to parse DH parameters in file"
632
" \"%s\": %s\n", dhparamsfilename,
633
safer_gnutls_strerror(ret));
634
dhparamsfilename = NULL;
635
}
636
free(params.data);
637
} while(false);
638
}
639
if(dhparamsfilename == NULL){
640
if(mc->dh_bits == 0){
641
/* Find out the optimal number of DH bits */
642
/* Try to read the private key file */
643
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
644
do {
645
int secfile = open(seckeyfilename, O_RDONLY);
646
if(secfile == -1){
647
perror_plus("open");
648
break;
649
}
650
size_t buffer_capacity = 0;
651
while(true){
652
buffer_capacity = incbuffer((char **)&buffer.data,
653
(size_t)buffer.size,
654
(size_t)buffer_capacity);
655
if(buffer_capacity == 0){
656
perror_plus("incbuffer");
657
free(buffer.data);
658
buffer.data = NULL;
659
break;
660
}
661
ssize_t bytes_read = read(secfile,
662
buffer.data + buffer.size,
663
BUFFER_SIZE);
664
/* EOF */
665
if(bytes_read == 0){
666
break;
667
}
668
/* check bytes_read for failure */
669
if(bytes_read < 0){
670
perror_plus("read");
671
free(buffer.data);
672
buffer.data = NULL;
673
break;
674
}
675
buffer.size += (unsigned int)bytes_read;
676
}
677
close(secfile);
678
} while(false);
679
/* If successful, use buffer to parse private key */
680
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
681
if(buffer.data != NULL){
682
{
683
gnutls_openpgp_privkey_t privkey = NULL;
684
ret = gnutls_openpgp_privkey_init(&privkey);
685
if(ret != GNUTLS_E_SUCCESS){
686
fprintf_plus(stderr, "Error initializing OpenPGP key"
687
" structure: %s",
688
safer_gnutls_strerror(ret));
689
free(buffer.data);
690
buffer.data = NULL;
691
} else {
692
ret = gnutls_openpgp_privkey_import
693
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
694
if(ret != GNUTLS_E_SUCCESS){
695
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
696
safer_gnutls_strerror(ret));
697
privkey = NULL;
698
}
699
free(buffer.data);
700
buffer.data = NULL;
701
if(privkey != NULL){
702
/* Use private key to suggest an appropriate
703
sec_param */
704
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
705
gnutls_openpgp_privkey_deinit(privkey);
706
if(debug){
707
fprintf_plus(stderr, "This OpenPGP key implies using"
708
" a GnuTLS security parameter \"%s\".\n",
709
safe_string(gnutls_sec_param_get_name
710
(sec_param)));
711
}
712
}
713
}
714
}
715
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
716
/* Err on the side of caution */
717
sec_param = GNUTLS_SEC_PARAM_ULTRA;
718
if(debug){
719
fprintf_plus(stderr, "Falling back to security parameter"
720
" \"%s\"\n",
721
safe_string(gnutls_sec_param_get_name
722
(sec_param)));
723
}
724
}
725
}
726
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
727
if(uret != 0){
728
mc->dh_bits = uret;
729
if(debug){
730
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
731
" implies %u DH bits; using that.\n",
732
safe_string(gnutls_sec_param_get_name
733
(sec_param)),
734
mc->dh_bits);
735
}
736
} else {
737
fprintf_plus(stderr, "Failed to get implied number of DH"
738
" bits for security parameter \"%s\"): %s\n",
739
safe_string(gnutls_sec_param_get_name
740
(sec_param)),
741
safer_gnutls_strerror(ret));
742
goto globalfail;
743
}
744
} else if(debug){
745
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
746
mc->dh_bits);
747
}
748
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
749
if(ret != GNUTLS_E_SUCCESS){
750
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
751
" bits): %s\n", mc->dh_bits,
752
safer_gnutls_strerror(ret));
753
goto globalfail;
754
}
755
}
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
756
579
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
757
580
758
581
return 0;
760
583
globalfail:
761
584
762
585
gnutls_certificate_free_credentials(mc->cred);
586
gnutls_global_deinit();
763
587
gnutls_dh_params_deinit(mc->dh_params);
764
588
return -1;
765
589
}
817
641
/* ignore client certificate if any. */
818
642
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
819
643
644
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
645
820
646
return 0;
821
647
}
822
648
824
650
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
825
651
__attribute__((unused)) const char *txt){}
826
652
827
/* Set effective uid to 0, return errno */
828
__attribute__((warn_unused_result))
829
int raise_privileges(void){
830
int old_errno = errno;
831
int ret = 0;
832
if(seteuid(0) == -1){
833
ret = errno;
834
}
835
errno = old_errno;
836
return ret;
837
}
838
839
/* Set effective and real user ID to 0. Return errno. */
840
__attribute__((warn_unused_result))
841
int raise_privileges_permanently(void){
842
int old_errno = errno;
843
int ret = raise_privileges();
844
if(ret != 0){
845
errno = old_errno;
846
return ret;
847
}
848
if(setuid(0) == -1){
849
ret = errno;
850
}
851
errno = old_errno;
852
return ret;
853
}
854
855
/* Set effective user ID to unprivileged saved user ID */
856
__attribute__((warn_unused_result))
857
int lower_privileges(void){
858
int old_errno = errno;
859
int ret = 0;
860
if(seteuid(uid) == -1){
861
ret = errno;
862
}
863
errno = old_errno;
864
return ret;
865
}
866
867
/* Lower privileges permanently */
868
__attribute__((warn_unused_result))
869
int lower_privileges_permanently(void){
870
int old_errno = errno;
871
int ret = 0;
872
if(setuid(uid) == -1){
873
ret = errno;
874
}
875
errno = old_errno;
876
return ret;
877
}
878
879
/* Helper function to add_local_route() and delete_local_route() */
880
__attribute__((nonnull, warn_unused_result))
881
static bool add_delete_local_route(const bool add,
882
const char *address,
883
AvahiIfIndex if_index){
884
int ret;
885
char helper[] = "mandos-client-iprouteadddel";
886
char add_arg[] = "add";
887
char delete_arg[] = "delete";
888
char debug_flag[] = "--debug";
889
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
890
if(pluginhelperdir == NULL){
891
if(debug){
892
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
893
" variable not set; cannot run helper\n");
894
}
895
return false;
896
}
897
898
char interface[IF_NAMESIZE];
899
if(if_indextoname((unsigned int)if_index, interface) == NULL){
900
perror_plus("if_indextoname");
901
return false;
902
}
903
904
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
905
if(devnull == -1){
906
perror_plus("open(\"/dev/null\", O_RDONLY)");
907
return false;
908
}
909
pid_t pid = fork();
910
if(pid == 0){
911
/* Child */
912
/* Raise privileges */
913
errno = raise_privileges_permanently();
914
if(errno != 0){
915
perror_plus("Failed to raise privileges");
916
/* _exit(EX_NOPERM); */
917
} else {
918
/* Set group */
919
errno = 0;
920
ret = setgid(0);
921
if(ret == -1){
922
perror_plus("setgid");
923
_exit(EX_NOPERM);
924
}
925
/* Reset supplementary groups */
926
errno = 0;
927
ret = setgroups(0, NULL);
928
if(ret == -1){
929
perror_plus("setgroups");
930
_exit(EX_NOPERM);
931
}
932
}
933
ret = dup2(devnull, STDIN_FILENO);
934
if(ret == -1){
935
perror_plus("dup2(devnull, STDIN_FILENO)");
936
_exit(EX_OSERR);
937
}
938
ret = close(devnull);
939
if(ret == -1){
940
perror_plus("close");
941
_exit(EX_OSERR);
942
}
943
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
944
if(ret == -1){
945
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
946
_exit(EX_OSERR);
947
}
948
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
949
O_RDONLY
950
| O_DIRECTORY
951
| O_PATH
952
| O_CLOEXEC));
953
if(helperdir_fd == -1){
954
perror_plus("open");
955
_exit(EX_UNAVAILABLE);
956
}
957
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
958
helper, O_RDONLY));
959
if(helper_fd == -1){
960
perror_plus("openat");
961
close(helperdir_fd);
962
_exit(EX_UNAVAILABLE);
963
}
964
close(helperdir_fd);
965
#ifdef __GNUC__
966
#pragma GCC diagnostic push
967
#pragma GCC diagnostic ignored "-Wcast-qual"
968
#endif
969
if(fexecve(helper_fd, (char *const [])
970
{ helper, add ? add_arg : delete_arg, (char *)address,
971
interface, debug ? debug_flag : NULL, NULL },
972
environ) == -1){
973
#ifdef __GNUC__
974
#pragma GCC diagnostic pop
975
#endif
976
perror_plus("fexecve");
977
_exit(EXIT_FAILURE);
978
}
979
}
980
if(pid == -1){
981
perror_plus("fork");
982
return false;
983
}
984
int status;
985
pid_t pret = -1;
986
errno = 0;
987
do {
988
pret = waitpid(pid, &status, 0);
989
if(pret == -1 and errno == EINTR and quit_now){
990
int errno_raising = 0;
991
if((errno = raise_privileges()) != 0){
992
errno_raising = errno;
993
perror_plus("Failed to raise privileges in order to"
994
" kill helper program");
995
}
996
if(kill(pid, SIGTERM) == -1){
997
perror_plus("kill");
998
}
999
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1000
perror_plus("Failed to lower privileges after killing"
1001
" helper program");
1002
}
1003
return false;
1004
}
1005
} while(pret == -1 and errno == EINTR);
1006
if(pret == -1){
1007
perror_plus("waitpid");
1008
return false;
1009
}
1010
if(WIFEXITED(status)){
1011
if(WEXITSTATUS(status) != 0){
1012
fprintf_plus(stderr, "Error: iprouteadddel exited"
1013
" with status %d\n", WEXITSTATUS(status));
1014
return false;
1015
}
1016
return true;
1017
}
1018
if(WIFSIGNALED(status)){
1019
fprintf_plus(stderr, "Error: iprouteadddel died by"
1020
" signal %d\n", WTERMSIG(status));
1021
return false;
1022
}
1023
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1024
return false;
1025
}
1026
1027
__attribute__((nonnull, warn_unused_result))
1028
static bool add_local_route(const char *address,
1029
AvahiIfIndex if_index){
1030
if(debug){
1031
fprintf_plus(stderr, "Adding route to %s\n", address);
1032
}
1033
return add_delete_local_route(true, address, if_index);
1034
}
1035
1036
__attribute__((nonnull, warn_unused_result))
1037
static bool delete_local_route(const char *address,
1038
AvahiIfIndex if_index){
1039
if(debug){
1040
fprintf_plus(stderr, "Removing route to %s\n", address);
1041
}
1042
return add_delete_local_route(false, address, if_index);
1043
}
1044
1045
653
/* Called when a Mandos server is found */
1046
654
__attribute__((nonnull, warn_unused_result))
1047
655
static int start_mandos_communication(const char *ip, in_port_t port,
1058
666
int retval = -1;
1059
667
gnutls_session_t session;
1060
668
int pf; /* Protocol family */
1061
bool route_added = false;
1062
669
1063
670
errno = 0;
1064
671
1086
693
bool match = false;
1087
694
{
1088
695
char *interface = NULL;
1089
while((interface = argz_next(mc->interfaces,
1090
mc->interfaces_size,
1091
interface))){
696
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
697
interface))){
1092
698
if(if_nametoindex(interface) == (unsigned int)if_index){
1093
699
match = true;
1094
700
break;
1123
729
PRIuMAX "\n", ip, (uintmax_t)port);
1124
730
}
1125
731
1126
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
732
tcp_sd = socket(pf, SOCK_STREAM, 0);
1127
733
if(tcp_sd < 0){
1128
734
int e = errno;
1129
735
perror_plus("socket");
1136
742
goto mandos_end;
1137
743
}
1138
744
745
memset(&to, 0, sizeof(to));
1139
746
if(af == AF_INET6){
1140
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1141
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1142
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);
1143
749
} else { /* IPv4 */
1144
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1145
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1146
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);
1147
752
}
1148
753
if(ret < 0 ){
1149
754
int e = errno;
1219
824
goto mandos_end;
1220
825
}
1221
826
1222
while(true){
1223
if(af == AF_INET6){
1224
ret = connect(tcp_sd, (struct sockaddr *)&to,
1225
sizeof(struct sockaddr_in6));
1226
} else {
1227
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1228
sizeof(struct sockaddr_in));
1229
}
1230
if(ret < 0){
1231
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1232
and if_index != AVAHI_IF_UNSPEC
1233
and connect_to == NULL
1234
and not route_added and
1235
((af == AF_INET6 and not
1236
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1237
&to)->sin6_addr)))
1238
or (af == AF_INET and
1239
/* Not a a IPv4LL address */
1240
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1241
& 0xFFFF0000L) != 0xA9FE0000L))){
1242
/* Work around Avahi bug - Avahi does not announce link-local
1243
addresses if it has a global address, so local hosts with
1244
*only* a link-local address (e.g. Mandos clients) cannot
1245
connect to a Mandos server announced by Avahi on a server
1246
host with a global address. Work around this by retrying
1247
with an explicit route added with the server's address.
1248
1249
Avahi bug reference:
1250
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1251
https://bugs.debian.org/587961
1252
*/
1253
if(debug){
1254
fprintf_plus(stderr, "Mandos server unreachable, trying"
1255
" direct route\n");
1256
}
1257
int e = errno;
1258
route_added = add_local_route(ip, if_index);
1259
if(route_added){
1260
continue;
1261
}
1262
errno = e;
1263
}
1264
if(errno != ECONNREFUSED or debug){
1265
int e = errno;
1266
perror_plus("connect");
1267
errno = e;
1268
}
1269
goto mandos_end;
1270
}
1271
1272
if(quit_now){
1273
errno = EINTR;
1274
goto mandos_end;
1275
}
1276
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;
1277
846
}
1278
847
1279
848
const char *out = mandos_protocol_version;
1433
1002
&decrypted_buffer, mc);
1434
1003
if(decrypted_buffer_size >= 0){
1435
1004
1436
clearerr(stdout);
1437
1005
written = 0;
1438
1006
while(written < (size_t) decrypted_buffer_size){
1439
1007
if(quit_now){
1455
1023
}
1456
1024
written += (size_t)ret;
1457
1025
}
1458
ret = fflush(stdout);
1459
if(ret != 0){
1460
int e = errno;
1461
if(debug){
1462
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1463
strerror(errno));
1464
}
1465
errno = e;
1466
goto mandos_end;
1467
}
1468
1026
retval = 0;
1469
1027
}
1470
1028
}
1473
1031
1474
1032
mandos_end:
1475
1033
{
1476
if(route_added){
1477
if(not delete_local_route(ip, if_index)){
1478
fprintf_plus(stderr, "Failed to delete local route to %s on"
1479
" interface %d", ip, if_index);
1480
}
1481
}
1482
1034
int e = errno;
1483
1035
free(decrypted_buffer);
1484
1036
free(buffer);
1485
1037
if(tcp_sd >= 0){
1486
ret = close(tcp_sd);
1038
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1487
1039
}
1488
1040
if(ret == -1){
1489
1041
if(e == 0){
1501
1053
return retval;
1502
1054
}
1503
1055
1056
__attribute__((nonnull))
1504
1057
static void resolve_callback(AvahiSServiceResolver *r,
1505
1058
AvahiIfIndex interface,
1506
1059
AvahiProtocol proto,
1643
1196
__attribute__((nonnull, warn_unused_result))
1644
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1645
1198
int ret;
1646
int old_errno;
1199
error_t ret_errno;
1647
1200
1648
1201
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1649
1202
if(s < 0){
1650
old_errno = errno;
1203
ret_errno = errno;
1651
1204
perror_plus("socket");
1652
errno = old_errno;
1205
errno = ret_errno;
1653
1206
return false;
1654
1207
}
1655
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1656
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1208
strcpy(ifr->ifr_name, ifname);
1657
1209
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1658
1210
if(ret == -1){
1659
1211
if(debug){
1660
old_errno = errno;
1212
ret_errno = errno;
1661
1213
perror_plus("ioctl SIOCGIFFLAGS");
1662
errno = old_errno;
1663
}
1664
if((close(s) == -1) and debug){
1665
old_errno = errno;
1666
perror_plus("close");
1667
errno = old_errno;
1214
errno = ret_errno;
1668
1215
}
1669
1216
return false;
1670
1217
}
1671
if((close(s) == -1) and debug){
1672
old_errno = errno;
1673
perror_plus("close");
1674
errno = old_errno;
1675
}
1676
1218
return true;
1677
1219
}
1678
1220
1920
1462
}
1921
1463
}
1922
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
1923
1517
__attribute__((nonnull))
1924
1518
void run_network_hooks(const char *mode, const char *interface,
1925
1519
const float delay){
1926
1520
struct dirent **direntries = NULL;
1927
1521
if(hookdir_fd == -1){
1928
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1929
| O_CLOEXEC);
1522
hookdir_fd = open(hookdir, O_RDONLY);
1930
1523
if(hookdir_fd == -1){
1931
1524
if(errno == ENOENT){
1932
1525
if(debug){
1939
1532
return;
1940
1533
}
1941
1534
}
1942
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1943
if(devnull == -1){
1944
perror_plus("open(\"/dev/null\", O_RDONLY)");
1945
return;
1946
}
1535
#ifdef __GLIBC__
1536
#if __GLIBC_PREREQ(2, 15)
1947
1537
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1948
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__ */
1949
1547
if(numhooks == -1){
1950
1548
perror_plus("scandir");
1951
close(devnull);
1952
1549
return;
1953
1550
}
1954
1551
struct dirent *direntry;
1955
1552
int ret;
1553
int devnull = open("/dev/null", O_RDONLY);
1956
1554
for(int i = 0; i < numhooks; i++){
1957
1555
direntry = direntries[i];
1958
1556
if(debug){
1982
1580
perror_plus("setgroups");
1983
1581
_exit(EX_NOPERM);
1984
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
}
1985
1598
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1986
1599
if(ret == -1){
1987
1600
perror_plus("setenv");
2022
1635
_exit(EX_OSERR);
2023
1636
}
2024
1637
}
2025
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2026
direntry->d_name,
2027
O_RDONLY));
1638
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2028
1639
if(hook_fd == -1){
2029
1640
perror_plus("openat");
2030
1641
_exit(EXIT_FAILURE);
2031
1642
}
2032
if(close(hookdir_fd) == -1){
1643
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2033
1644
perror_plus("close");
2034
1645
_exit(EXIT_FAILURE);
2035
1646
}
2036
ret = dup2(devnull, STDIN_FILENO);
2037
if(ret == -1){
2038
perror_plus("dup2(devnull, STDIN_FILENO)");
2039
_exit(EX_OSERR);
2040
}
2041
ret = close(devnull);
2042
if(ret == -1){
2043
perror_plus("close");
2044
_exit(EX_OSERR);
2045
}
2046
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2047
if(ret == -1){
2048
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2049
_exit(EX_OSERR);
2050
}
2051
1647
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2052
1648
environ) == -1){
2053
1649
perror_plus("fexecve");
2054
1650
_exit(EXIT_FAILURE);
2055
1651
}
2056
1652
} else {
2057
if(hook_pid == -1){
2058
perror_plus("fork");
2059
free(direntry);
2060
continue;
2061
}
2062
1653
int status;
2063
1654
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2064
1655
perror_plus("waitpid");
2093
1684
free(direntry);
2094
1685
}
2095
1686
free(direntries);
2096
if(close(hookdir_fd) == -1){
1687
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2097
1688
perror_plus("close");
2098
1689
} else {
2099
1690
hookdir_fd = -1;
2102
1693
}
2103
1694
2104
1695
__attribute__((nonnull, warn_unused_result))
2105
int bring_up_interface(const char *const interface,
2106
const float delay){
2107
int old_errno = errno;
1696
error_t bring_up_interface(const char *const interface,
1697
const float delay){
1698
error_t old_errno = errno;
2108
1699
int ret;
2109
1700
struct ifreq network;
2110
1701
unsigned int if_index = if_nametoindex(interface);
2120
1711
}
2121
1712
2122
1713
if(not interface_is_up(interface)){
2123
int ret_errno = 0;
2124
int ioctl_errno = 0;
1714
error_t ret_errno = 0, ioctl_errno = 0;
2125
1715
if(not get_flags(interface, &network)){
2126
1716
ret_errno = errno;
2127
1717
fprintf_plus(stderr, "Failed to get flags for interface "
2140
1730
}
2141
1731
2142
1732
if(quit_now){
2143
ret = close(sd);
1733
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2144
1734
if(ret == -1){
2145
1735
perror_plus("close");
2146
1736
}
2196
1786
}
2197
1787
2198
1788
/* Close the socket */
2199
ret = close(sd);
1789
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2200
1790
if(ret == -1){
2201
1791
perror_plus("close");
2202
1792
}
2214
1804
2215
1805
/* Sleep checking until interface is running.
2216
1806
Check every 0.25s, up to total time of delay */
2217
for(int i = 0; i < delay * 4; i++){
1807
for(int i=0; i < delay * 4; i++){
2218
1808
if(interface_is_running(interface)){
2219
1809
break;
2220
1810
}
2230
1820
}
2231
1821
2232
1822
__attribute__((nonnull, warn_unused_result))
2233
int take_down_interface(const char *const interface){
2234
int old_errno = errno;
1823
error_t take_down_interface(const char *const interface){
1824
error_t old_errno = errno;
2235
1825
struct ifreq network;
2236
1826
unsigned int if_index = if_nametoindex(interface);
2237
1827
if(if_index == 0){
2240
1830
return ENXIO;
2241
1831
}
2242
1832
if(interface_is_up(interface)){
2243
int ret_errno = 0;
2244
int ioctl_errno = 0;
1833
error_t ret_errno = 0, ioctl_errno = 0;
2245
1834
if(not get_flags(interface, &network) and debug){
2246
1835
ret_errno = errno;
2247
1836
fprintf_plus(stderr, "Failed to get flags for interface "
2285
1874
}
2286
1875
2287
1876
/* Close the socket */
2288
int ret = close(sd);
1877
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2289
1878
if(ret == -1){
2290
1879
perror_plus("close");
2291
1880
}
2306
1895
}
2307
1896
2308
1897
int main(int argc, char *argv[]){
2309
mandos_context mc = { .server = NULL, .dh_bits = 0,
2310
.priority = "SECURE256:!CTYPE-X.509"
2311
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2312
.current_server = NULL, .interfaces = NULL,
2313
.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 };
2314
1902
AvahiSServiceBrowser *sb = NULL;
2315
1903
error_t ret_errno;
2316
1904
int ret;
2325
1913
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2326
1914
const char *seckey = PATHDIR "/" SECKEY;
2327
1915
const char *pubkey = PATHDIR "/" PUBKEY;
2328
const char *dh_params_file = NULL;
2329
1916
char *interfaces_hooks = NULL;
2330
1917
2331
1918
bool gnutls_initialized = false;
2384
1971
.doc = "Bit length of the prime number used in the"
2385
1972
" Diffie-Hellman key exchange",
2386
1973
.group = 2 },
2387
{ .name = "dh-params", .key = 134,
2388
.arg = "FILE",
2389
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2390
" for the Diffie-Hellman key exchange",
2391
.group = 2 },
2392
1974
{ .name = "priority", .key = 130,
2393
1975
.arg = "STRING",
2394
1976
.doc = "GnuTLS priority string for the TLS handshake",
2449
2031
}
2450
2032
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2451
2033
break;
2452
case 134: /* --dh-params */
2453
dh_params_file = arg;
2454
break;
2455
2034
case 130: /* --priority */
2456
2035
mc.priority = arg;
2457
2036
break;
2497
2076
.args_doc = "",
2498
2077
.doc = "Mandos client -- Get and decrypt"
2499
2078
" passwords from a Mandos server" };
2500
ret_errno = argp_parse(&argp, argc, argv,
2501
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2502
switch(ret_errno){
2079
ret = argp_parse(&argp, argc, argv,
2080
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2081
switch(ret){
2503
2082
case 0:
2504
2083
break;
2505
2084
case ENOMEM:
2506
2085
default:
2507
errno = ret_errno;
2086
errno = ret;
2508
2087
perror_plus("argp_parse");
2509
2088
exitcode = EX_OSERR;
2510
2089
goto end;
2513
2092
goto end;
2514
2093
}
2515
2094
}
2516
2095
2517
2096
{
2518
2097
/* Work around Debian bug #633582:
2519
<https://bugs.debian.org/633582> */
2098
<http://bugs.debian.org/633582> */
2520
2099
2521
2100
/* Re-raise privileges */
2522
ret = raise_privileges();
2523
if(ret != 0){
2524
errno = ret;
2101
ret_errno = raise_privileges();
2102
if(ret_errno != 0){
2103
errno = ret_errno;
2525
2104
perror_plus("Failed to raise privileges");
2526
2105
} else {
2527
2106
struct stat st;
2543
2122
}
2544
2123
}
2545
2124
}
2546
close(seckey_fd);
2125
TEMP_FAILURE_RETRY(close(seckey_fd));
2547
2126
}
2548
2127
}
2549
2128
2550
2129
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2551
2130
int pubkey_fd = open(pubkey, O_RDONLY);
2552
2131
if(pubkey_fd == -1){
2564
2143
}
2565
2144
}
2566
2145
}
2567
close(pubkey_fd);
2568
}
2569
}
2570
2571
if(dh_params_file != NULL
2572
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2573
int dhparams_fd = open(dh_params_file, O_RDONLY);
2574
if(dhparams_fd == -1){
2575
perror_plus("open");
2576
} else {
2577
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2578
if(ret == -1){
2579
perror_plus("fstat");
2580
} else {
2581
if(S_ISREG(st.st_mode)
2582
and st.st_uid == 0 and st.st_gid == 0){
2583
ret = fchown(dhparams_fd, uid, gid);
2584
if(ret == -1){
2585
perror_plus("fchown");
2586
}
2587
}
2588
}
2589
close(dhparams_fd);
2590
}
2591
}
2592
2146
TEMP_FAILURE_RETRY(close(pubkey_fd));
2147
}
2148
}
2149
2593
2150
/* Lower privileges */
2594
ret = lower_privileges();
2595
if(ret != 0){
2596
errno = ret;
2151
ret_errno = lower_privileges();
2152
if(ret_errno != 0){
2153
errno = ret_errno;
2597
2154
perror_plus("Failed to lower privileges");
2598
2155
}
2599
2156
}
2769
2326
errno = bring_up_interface(interface, delay);
2770
2327
if(not interface_was_up){
2771
2328
if(errno != 0){
2772
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2773
" %s\n", interface, strerror(errno));
2329
perror_plus("Failed to bring up interface");
2774
2330
} else {
2775
2331
errno = argz_add(&interfaces_to_take_down,
2776
2332
&interfaces_to_take_down_size,
2799
2355
goto end;
2800
2356
}
2801
2357
2802
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2358
ret = init_gnutls_global(pubkey, seckey, &mc);
2803
2359
if(ret == -1){
2804
2360
fprintf_plus(stderr, "init_gnutls_global failed\n");
2805
2361
exitcode = EX_UNAVAILABLE;
2927
2483
2928
2484
/* Allocate a new server */
2929
2485
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2930
&config, NULL, NULL, &ret);
2486
&config, NULL, NULL, &ret_errno);
2931
2487
2932
2488
/* Free the Avahi configuration data */
2933
2489
avahi_server_config_free(&config);
2936
2492
/* Check if creating the Avahi server object succeeded */
2937
2493
if(mc.server == NULL){
2938
2494
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2939
avahi_strerror(ret));
2495
avahi_strerror(ret_errno));
2940
2496
exitcode = EX_UNAVAILABLE;
2941
2497
goto end;
2942
2498
}
2977
2533
end:
2978
2534
2979
2535
if(debug){
2980
if(signal_received){
2981
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
2982
argv[0], signal_received,
2983
strsignal(signal_received));
2984
} else {
2985
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2986
}
2536
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2987
2537
}
2988
2538
2989
2539
/* Cleanup things */
3000
2550
3001
2551
if(gnutls_initialized){
3002
2552
gnutls_certificate_free_credentials(mc.cred);
2553
gnutls_global_deinit();
3003
2554
gnutls_dh_params_deinit(mc.dh_params);
3004
2555
}
3005
2556
3028
2579
3029
2580
/* Re-raise privileges */
3030
2581
{
3031
ret = raise_privileges();
3032
if(ret != 0){
3033
errno = ret;
2582
ret_errno = raise_privileges();
2583
if(ret_errno != 0){
2584
errno = ret_errno;
3034
2585
perror_plus("Failed to raise privileges");
3035
2586
} else {
3036
2587
3041
2592
/* Take down the network interfaces which were brought up */
3042
2593
{
3043
2594
char *interface = NULL;
3044
while((interface = argz_next(interfaces_to_take_down,
3045
interfaces_to_take_down_size,
3046
interface))){
3047
ret = take_down_interface(interface);
3048
if(ret != 0){
3049
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;
3050
2601
perror_plus("Failed to take down interface");
3051
2602
}
3052
2603
}
3057
2608
}
3058
2609
}
3059
2610
3060
ret = lower_privileges_permanently();
3061
if(ret != 0){
3062
errno = ret;
2611
ret_errno = lower_privileges_permanently();
2612
if(ret_errno != 0){
2613
errno = ret_errno;
3063
2614
perror_plus("Failed to lower privileges permanently");
3064
2615
}
3065
2616
}
3067
2618
free(interfaces_to_take_down);
3068
2619
free(interfaces_hooks);
3069
2620
3070
void clean_dir_at(int base, const char * const dirname,
3071
uintmax_t level){
3072
struct dirent **direntries = NULL;
3073
int dret;
3074
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3075
O_RDONLY
3076
| O_NOFOLLOW
3077
| O_DIRECTORY
3078
| O_PATH));
3079
if(dir_fd == -1){
3080
perror_plus("open");
3081
return;
3082
}
3083
int numentries = scandirat(dir_fd, ".", &direntries,
3084
notdotentries, alphasort);
3085
if(numentries >= 0){
3086
for(int i = 0; i < numentries; i++){
3087
if(debug){
3088
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3089
dirname, direntries[i]->d_name);
3090
}
3091
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3092
if(dret == -1){
3093
if(errno == EISDIR){
3094
dret = unlinkat(dir_fd, direntries[i]->d_name,
3095
AT_REMOVEDIR);
3096
}
3097
if((dret == -1) and (errno == ENOTEMPTY)
3098
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3099
== 0) and (level == 0)){
3100
/* Recurse only in this special case */
3101
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3102
dret = 0;
3103
}
3104
if((dret == -1) and (errno != ENOENT)){
3105
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3106
direntries[i]->d_name, strerror(errno));
3107
}
3108
}
3109
free(direntries[i]);
3110
}
3111
3112
/* need to clean even if 0 because man page doesn't specify */
3113
free(direntries);
3114
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3115
if(dret == -1 and errno != ENOENT){
3116
perror_plus("rmdir");
3117
}
3118
} else {
3119
perror_plus("scandirat");
3120
}
3121
close(dir_fd);
3122
}
3123
3124
2621
/* Removes the GPGME temp directory and all files inside */
3125
2622
if(tempdir != NULL){
3126
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
}
3127
2664
}
3128
2665
3129
2666
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0