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
}
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 **)¶ms.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, ¶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);
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){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0