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).
- files added:
- debian/upstream
- files modified:
- DBUS-API
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-2013 Teddy Hogeborn
13
* Copyright © 2008-2013 Björn Påhlsson
12
* Copyright © 2008-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 Björn Påhlsson
14
14
*
15
15
* This program is free software: you can redistribute it and/or
16
16
* modify it under the terms of the GNU General Public License as
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
#endif
35
#endif /* not _LARGEFILE_SOURCE */
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
#endif
38
#endif /* not _FILE_OFFSET_BITS */
39
39
40
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
42
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
43
stdout, ferror() */
44
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
55
55
opendir(), DIR */
56
56
#include <sys/stat.h> /* open(), S_ISREG */
57
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
58
inet_pton(), connect(),
59
getnameinfo() */
60
#include <fcntl.h> /* open(), unlinkat() */
60
61
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
62
*/
62
63
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
72
73
*/
73
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
75
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
76
setgid(), pause(), _exit(),
77
unlinkat() */
78
#include <arpa/inet.h> /* inet_pton(), htons() */
77
79
#include <iso646.h> /* not, or, and */
78
80
#include <argp.h> /* struct argp_option, error_t, struct
79
81
argp_state, struct argp,
91
93
argz_delete(), argz_append(),
92
94
argz_stringify(), argz_add(),
93
95
argz_count() */
96
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
97
EAI_SYSTEM, gai_strerror() */
94
98
95
99
#ifdef __linux__
96
100
#include <sys/klog.h> /* klogctl() */
138
142
static const char sys_class_net[] = "/sys/class/net";
139
143
char *connect_to = NULL;
140
144
const char *hookdir = HOOKDIR;
145
int hookdir_fd = -1;
141
146
uid_t uid = 65534;
142
147
gid_t gid = 65534;
143
148
180
185
perror(print_text);
181
186
}
182
187
183
__attribute__((format (gnu_printf, 2, 3)))
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
184
189
int fprintf_plus(FILE *stream, const char *format, ...){
185
190
va_list ap;
186
191
va_start (ap, format);
195
200
* bytes. "buffer_capacity" is how much is currently allocated,
196
201
* "buffer_length" is how much is already used.
197
202
*/
203
__attribute__((nonnull, warn_unused_result))
198
204
size_t incbuffer(char **buffer, size_t buffer_length,
199
205
size_t buffer_capacity){
200
206
if(buffer_length + BUFFER_SIZE > buffer_capacity){
201
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
202
if(buffer == NULL){
207
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
208
if(new_buf == NULL){
209
int old_errno = errno;
210
free(*buffer);
211
errno = old_errno;
212
*buffer = NULL;
203
213
return 0;
204
214
}
215
*buffer = new_buf;
205
216
buffer_capacity += BUFFER_SIZE;
206
217
}
207
218
return buffer_capacity;
208
219
}
209
220
210
221
/* Add server to set of servers to retry periodically */
222
__attribute__((nonnull, warn_unused_result))
211
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
212
224
int af, server **current_server){
213
225
int ret;
222
234
.af = af };
223
235
if(new_server->ip == NULL){
224
236
perror_plus("strdup");
237
free(new_server);
238
return false;
239
}
240
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
241
if(ret == -1){
242
perror_plus("clock_gettime");
243
#ifdef __GNUC__
244
#pragma GCC diagnostic push
245
#pragma GCC diagnostic ignored "-Wcast-qual"
246
#endif
247
free((char *)(new_server->ip));
248
#ifdef __GNUC__
249
#pragma GCC diagnostic pop
250
#endif
251
free(new_server);
225
252
return false;
226
253
}
227
254
/* Special case of first server */
229
256
new_server->next = new_server;
230
257
new_server->prev = new_server;
231
258
*current_server = new_server;
232
/* Place the new server last in the list */
233
259
} else {
260
/* Place the new server last in the list */
234
261
new_server->next = *current_server;
235
262
new_server->prev = (*current_server)->prev;
236
263
new_server->prev->next = new_server;
237
264
(*current_server)->prev = new_server;
238
265
}
239
ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
240
if(ret == -1){
241
perror_plus("clock_gettime");
242
return false;
243
}
244
266
return true;
245
267
}
246
268
247
269
/*
248
270
* Initialize GPGME.
249
271
*/
250
static bool init_gpgme(const char *seckey, const char *pubkey,
251
const char *tempdir, mandos_context *mc){
272
__attribute__((nonnull, warn_unused_result))
273
static bool init_gpgme(const char * const seckey,
274
const char * const pubkey,
275
const char * const tempdir,
276
mandos_context *mc){
252
277
gpgme_error_t rc;
253
278
gpgme_engine_info_t engine_info;
254
279
255
280
/*
256
281
* Helper function to insert pub and seckey to the engine keyring.
257
282
*/
258
bool import_key(const char *filename){
283
bool import_key(const char * const filename){
259
284
int ret;
260
285
int fd;
261
286
gpgme_data_t pgp_data;
342
367
* Decrypt OpenPGP data.
343
368
* Returns -1 on error
344
369
*/
370
__attribute__((nonnull, warn_unused_result))
345
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
372
size_t crypto_size,
347
373
char **plaintext,
467
493
return plaintext_length;
468
494
}
469
495
470
static const char * safer_gnutls_strerror(int value){
496
__attribute__((warn_unused_result, const))
497
static const char *safe_string(const char *str){
498
if(str == NULL)
499
return "(unknown)";
500
return str;
501
}
502
503
__attribute__((warn_unused_result))
504
static const char *safer_gnutls_strerror(int value){
471
505
const char *ret = gnutls_strerror(value);
472
if(ret == NULL)
473
ret = "(unknown)";
474
return ret;
506
return safe_string(ret);
475
507
}
476
508
477
509
/* GnuTLS log function callback */
510
__attribute__((nonnull))
478
511
static void debuggnutls(__attribute__((unused)) int level,
479
512
const char* string){
480
513
fprintf_plus(stderr, "GnuTLS: %s", string);
481
514
}
482
515
516
__attribute__((nonnull, warn_unused_result))
483
517
static int init_gnutls_global(const char *pubkeyfilename,
484
518
const char *seckeyfilename,
485
519
mandos_context *mc){
486
520
int ret;
521
unsigned int uret;
487
522
488
523
if(debug){
489
524
fprintf_plus(stderr, "Initializing GnuTLS\n");
540
575
safer_gnutls_strerror(ret));
541
576
goto globalfail;
542
577
}
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;
585
while(true){
586
buffer_capacity = incbuffer((char **)&buffer.data,
587
(size_t)buffer.size,
588
(size_t)buffer_capacity);
589
if(buffer_capacity == 0){
590
perror_plus("incbuffer");
591
free(buffer.data);
592
buffer.data = NULL;
593
break;
594
}
595
ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
596
BUFFER_SIZE);
597
/* EOF */
598
if(bytes_read == 0){
599
break;
600
}
601
/* check bytes_read for failure */
602
if(bytes_read < 0){
603
perror_plus("read");
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);
627
if(ret != GNUTLS_E_SUCCESS){
628
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
629
safer_gnutls_strerror(ret));
630
privkey = NULL;
631
}
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
}
644
}
645
}
646
}
647
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
648
/* Err on the side of caution */
649
sec_param = GNUTLS_SEC_PARAM_ULTRA;
650
if(debug){
651
fprintf_plus(stderr, "Falling back to security parameter"
652
" \"%s\"\n",
653
safe_string(gnutls_sec_param_get_name
654
(sec_param)));
655
}
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",
664
safe_string(gnutls_sec_param_get_name
665
(sec_param)),
666
mc->dh_bits);
667
}
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)),
672
safer_gnutls_strerror(ret));
673
goto globalfail;
674
}
675
} else if(debug){
676
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
677
mc->dh_bits);
678
}
543
679
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
544
680
if(ret != GNUTLS_E_SUCCESS){
545
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
546
safer_gnutls_strerror(ret));
681
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
682
" %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
547
683
goto globalfail;
548
684
}
549
685
559
695
return -1;
560
696
}
561
697
698
__attribute__((nonnull, warn_unused_result))
562
699
static int init_gnutls_session(gnutls_session_t *session,
563
700
mandos_context *mc){
564
701
int ret;
621
758
__attribute__((unused)) const char *txt){}
622
759
623
760
/* Called when a Mandos server is found */
761
__attribute__((nonnull, warn_unused_result))
624
762
static int start_mandos_communication(const char *ip, in_port_t port,
625
763
AvahiIfIndex if_index,
626
764
int af, mandos_context *mc){
627
765
int ret, tcp_sd = -1;
628
766
ssize_t sret;
629
union {
630
struct sockaddr_in in;
631
struct sockaddr_in6 in6;
632
} to;
767
struct sockaddr_storage to;
633
768
char *buffer = NULL;
634
769
char *decrypted_buffer = NULL;
635
770
size_t buffer_length = 0;
716
851
717
852
memset(&to, 0, sizeof(to));
718
853
if(af == AF_INET6){
719
to.in6.sin6_family = (sa_family_t)af;
720
ret = inet_pton(af, ip, &to.in6.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);
721
856
} else { /* IPv4 */
722
to.in.sin_family = (sa_family_t)af;
723
ret = inet_pton(af, ip, &to.in.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);
724
859
}
725
860
if(ret < 0 ){
726
861
int e = errno;
735
870
goto mandos_end;
736
871
}
737
872
if(af == AF_INET6){
738
to.in6.sin6_port = htons(port);
739
#ifdef __GNUC__
740
#pragma GCC diagnostic push
741
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
742
#endif
743
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
744
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower */
745
#ifdef __GNUC__
746
#pragma GCC diagnostic pop
747
#endif
873
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
874
if(IN6_IS_ADDR_LINKLOCAL
875
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
748
876
if(if_index == AVAHI_IF_UNSPEC){
749
877
fprintf_plus(stderr, "An IPv6 link-local address is"
750
878
" incomplete without a network interface\n");
752
880
goto mandos_end;
753
881
}
754
882
/* Set the network interface number as scope */
755
to.in6.sin6_scope_id = (uint32_t)if_index;
883
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
756
884
}
757
885
} else {
758
to.in.sin_port = htons(port);
886
((struct sockaddr_in *)&to)->sin_port = htons(port);
759
887
}
760
888
761
889
if(quit_now){
778
906
}
779
907
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
780
908
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
781
const char *pcret;
782
909
if(af == AF_INET6){
783
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
784
sizeof(addrstr));
910
ret = getnameinfo((struct sockaddr *)&to,
911
sizeof(struct sockaddr_in6),
912
addrstr, sizeof(addrstr), NULL, 0,
913
NI_NUMERICHOST);
785
914
} else {
786
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
787
sizeof(addrstr));
915
ret = getnameinfo((struct sockaddr *)&to,
916
sizeof(struct sockaddr_in),
917
addrstr, sizeof(addrstr), NULL, 0,
918
NI_NUMERICHOST);
788
919
}
789
if(pcret == NULL){
790
perror_plus("inet_ntop");
791
} else {
792
if(strcmp(addrstr, ip) != 0){
793
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
794
}
920
if(ret == EAI_SYSTEM){
921
perror_plus("getnameinfo");
922
} else if(ret != 0) {
923
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
924
} else if(strcmp(addrstr, ip) != 0){
925
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
795
926
}
796
927
}
797
928
801
932
}
802
933
803
934
if(af == AF_INET6){
804
ret = connect(tcp_sd, &to.in6, sizeof(to));
935
ret = connect(tcp_sd, (struct sockaddr *)&to,
936
sizeof(struct sockaddr_in6));
805
937
} else {
806
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
938
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
939
sizeof(struct sockaddr_in));
807
940
}
808
941
if(ret < 0){
809
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
942
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
810
943
int e = errno;
811
944
perror_plus("connect");
812
945
errno = e;
1027
1160
return retval;
1028
1161
}
1029
1162
1163
__attribute__((nonnull))
1030
1164
static void resolve_callback(AvahiSServiceResolver *r,
1031
1165
AvahiIfIndex interface,
1032
1166
AvahiProtocol proto,
1040
1174
AVAHI_GCC_UNUSED AvahiStringList *txt,
1041
1175
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1042
1176
flags,
1043
void* mc){
1177
void *mc){
1044
1178
if(r == NULL){
1045
1179
return;
1046
1180
}
1049
1183
timed out */
1050
1184
1051
1185
if(quit_now){
1186
avahi_s_service_resolver_free(r);
1052
1187
return;
1053
1188
}
1054
1189
1099
1234
const char *domain,
1100
1235
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1101
1236
flags,
1102
void* mc){
1237
void *mc){
1103
1238
if(b == NULL){
1104
1239
return;
1105
1240
}
1165
1300
errno = old_errno;
1166
1301
}
1167
1302
1303
__attribute__((nonnull, warn_unused_result))
1168
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1169
1305
int ret;
1170
1306
error_t ret_errno;
1189
1325
return true;
1190
1326
}
1191
1327
1328
__attribute__((nonnull, warn_unused_result))
1192
1329
bool good_flags(const char *ifname, const struct ifreq *ifr){
1193
1330
1194
1331
/* Reject the loopback device */
1236
1373
* corresponds to an acceptable network device.
1237
1374
* (This function is passed to scandir(3) as a filter function.)
1238
1375
*/
1376
__attribute__((nonnull, warn_unused_result))
1239
1377
int good_interface(const struct dirent *if_entry){
1240
1378
if(if_entry->d_name[0] == '.'){
1241
1379
return 0;
1259
1397
/*
1260
1398
* This function determines if a network interface is up.
1261
1399
*/
1400
__attribute__((nonnull, warn_unused_result))
1262
1401
bool interface_is_up(const char *interface){
1263
1402
struct ifreq ifr;
1264
1403
if(not get_flags(interface, &ifr)){
1275
1414
/*
1276
1415
* This function determines if a network interface is running
1277
1416
*/
1417
__attribute__((nonnull, warn_unused_result))
1278
1418
bool interface_is_running(const char *interface){
1279
1419
struct ifreq ifr;
1280
1420
if(not get_flags(interface, &ifr)){
1288
1428
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1289
1429
}
1290
1430
1431
__attribute__((nonnull, pure, warn_unused_result))
1291
1432
int notdotentries(const struct dirent *direntry){
1292
1433
/* Skip "." and ".." */
1293
1434
if(direntry->d_name[0] == '.'
1300
1441
}
1301
1442
1302
1443
/* Is this directory entry a runnable program? */
1444
__attribute__((nonnull, warn_unused_result))
1303
1445
int runnable_hook(const struct dirent *direntry){
1304
1446
int ret;
1305
1447
size_t sret;
1313
1455
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1314
1456
"abcdefghijklmnopqrstuvwxyz"
1315
1457
"0123456789"
1316
"_-");
1458
"_.-");
1317
1459
if((direntry->d_name)[sret] != '\0'){
1318
1460
/* Contains non-allowed characters */
1319
1461
if(debug){
1323
1465
return 0;
1324
1466
}
1325
1467
1326
char *fullname = NULL;
1327
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1328
if(ret < 0){
1329
perror_plus("asprintf");
1330
return 0;
1331
}
1332
1333
ret = stat(fullname, &st);
1468
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1334
1469
if(ret == -1){
1335
1470
if(debug){
1336
1471
perror_plus("Could not stat hook");
1360
1495
return 1;
1361
1496
}
1362
1497
1498
__attribute__((nonnull, warn_unused_result))
1363
1499
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1364
1500
mandos_context *mc){
1365
1501
int ret;
1369
1505
1370
1506
while(true){
1371
1507
if(mc->current_server == NULL){
1372
if (debug){
1508
if(debug){
1373
1509
fprintf_plus(stderr, "Wait until first server is found."
1374
1510
" No timeout!\n");
1375
1511
}
1376
1512
ret = avahi_simple_poll_iterate(s, -1);
1377
1513
} else {
1378
if (debug){
1514
if(debug){
1379
1515
fprintf_plus(stderr, "Check current_server if we should run"
1380
1516
" it, or wait\n");
1381
1517
}
1398
1534
- ((intmax_t)waited_time.tv_sec * 1000))
1399
1535
- ((intmax_t)waited_time.tv_nsec / 1000000));
1400
1536
1401
if (debug){
1537
if(debug){
1402
1538
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1403
1539
block_time);
1404
1540
}
1426
1562
ret = avahi_simple_poll_iterate(s, (int)block_time);
1427
1563
}
1428
1564
if(ret != 0){
1429
if (ret > 0 or errno != EINTR){
1565
if(ret > 0 or errno != EINTR){
1430
1566
return (ret != 1) ? ret : 0;
1431
1567
}
1432
1568
}
1434
1570
}
1435
1571
1436
1572
/* Set effective uid to 0, return errno */
1573
__attribute__((warn_unused_result))
1437
1574
error_t raise_privileges(void){
1438
1575
error_t old_errno = errno;
1439
1576
error_t ret_errno = 0;
1440
1577
if(seteuid(0) == -1){
1441
1578
ret_errno = errno;
1442
perror_plus("seteuid");
1443
1579
}
1444
1580
errno = old_errno;
1445
1581
return ret_errno;
1446
1582
}
1447
1583
1448
1584
/* Set effective and real user ID to 0. Return errno. */
1585
__attribute__((warn_unused_result))
1449
1586
error_t raise_privileges_permanently(void){
1450
1587
error_t old_errno = errno;
1451
1588
error_t ret_errno = raise_privileges();
1455
1592
}
1456
1593
if(setuid(0) == -1){
1457
1594
ret_errno = errno;
1458
perror_plus("seteuid");
1459
1595
}
1460
1596
errno = old_errno;
1461
1597
return ret_errno;
1462
1598
}
1463
1599
1464
1600
/* Set effective user ID to unprivileged saved user ID */
1601
__attribute__((warn_unused_result))
1465
1602
error_t lower_privileges(void){
1466
1603
error_t old_errno = errno;
1467
1604
error_t ret_errno = 0;
1468
1605
if(seteuid(uid) == -1){
1469
1606
ret_errno = errno;
1470
perror_plus("seteuid");
1471
1607
}
1472
1608
errno = old_errno;
1473
1609
return ret_errno;
1474
1610
}
1475
1611
1476
1612
/* Lower privileges permanently */
1613
__attribute__((warn_unused_result))
1477
1614
error_t lower_privileges_permanently(void){
1478
1615
error_t old_errno = errno;
1479
1616
error_t ret_errno = 0;
1480
1617
if(setuid(uid) == -1){
1481
1618
ret_errno = errno;
1482
perror_plus("setuid");
1483
1619
}
1484
1620
errno = old_errno;
1485
1621
return ret_errno;
1486
1622
}
1487
1623
1488
bool run_network_hooks(const char *mode, const char *interface,
1624
__attribute__((nonnull))
1625
void run_network_hooks(const char *mode, const char *interface,
1489
1626
const float delay){
1490
struct dirent **direntries;
1627
struct dirent **direntries = NULL;
1628
if(hookdir_fd == -1){
1629
hookdir_fd = open(hookdir, O_RDONLY);
1630
if(hookdir_fd == -1){
1631
if(errno == ENOENT){
1632
if(debug){
1633
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1634
" found\n", hookdir);
1635
}
1636
} else {
1637
perror_plus("open");
1638
}
1639
return;
1640
}
1641
}
1642
#ifdef __GLIBC__
1643
#if __GLIBC_PREREQ(2, 15)
1644
int numhooks = scandirat(hookdir_fd, ".", &direntries,
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__ */
1654
if(numhooks == -1){
1655
perror_plus("scandir");
1656
return;
1657
}
1491
1658
struct dirent *direntry;
1492
1659
int ret;
1493
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1494
alphasort);
1495
if(numhooks == -1){
1496
if(errno == ENOENT){
1497
if(debug){
1498
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1499
" found\n", hookdir);
1500
}
1501
} else {
1502
perror_plus("scandir");
1660
int devnull = open("/dev/null", O_RDONLY);
1661
for(int i = 0; i < numhooks; i++){
1662
direntry = direntries[i];
1663
if(debug){
1664
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1665
direntry->d_name);
1503
1666
}
1504
} else {
1505
int devnull = open("/dev/null", O_RDONLY);
1506
for(int i = 0; i < numhooks; i++){
1507
direntry = direntries[i];
1508
char *fullname = NULL;
1509
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1510
if(ret < 0){
1667
pid_t hook_pid = fork();
1668
if(hook_pid == 0){
1669
/* Child */
1670
/* Raise privileges */
1671
errno = raise_privileges_permanently();
1672
if(errno != 0){
1673
perror_plus("Failed to raise privileges");
1674
_exit(EX_NOPERM);
1675
}
1676
/* Set group */
1677
errno = 0;
1678
ret = setgid(0);
1679
if(ret == -1){
1680
perror_plus("setgid");
1681
_exit(EX_NOPERM);
1682
}
1683
/* Reset supplementary groups */
1684
errno = 0;
1685
ret = setgroups(0, NULL);
1686
if(ret == -1){
1687
perror_plus("setgroups");
1688
_exit(EX_NOPERM);
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
}
1705
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1706
if(ret == -1){
1707
perror_plus("setenv");
1708
_exit(EX_OSERR);
1709
}
1710
ret = setenv("DEVICE", interface, 1);
1711
if(ret == -1){
1712
perror_plus("setenv");
1713
_exit(EX_OSERR);
1714
}
1715
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1716
if(ret == -1){
1717
perror_plus("setenv");
1718
_exit(EX_OSERR);
1719
}
1720
ret = setenv("MODE", mode, 1);
1721
if(ret == -1){
1722
perror_plus("setenv");
1723
_exit(EX_OSERR);
1724
}
1725
char *delaystring;
1726
ret = asprintf(&delaystring, "%f", (double)delay);
1727
if(ret == -1){
1511
1728
perror_plus("asprintf");
1512
continue;
1513
}
1514
if(debug){
1515
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1516
direntry->d_name);
1517
}
1518
pid_t hook_pid = fork();
1519
if(hook_pid == 0){
1520
/* Child */
1521
/* Raise privileges */
1522
raise_privileges_permanently();
1523
/* Set group */
1524
errno = 0;
1525
ret = setgid(0);
1526
if(ret == -1){
1527
perror_plus("setgid");
1528
}
1529
/* Reset supplementary groups */
1530
errno = 0;
1531
ret = setgroups(0, NULL);
1532
if(ret == -1){
1533
perror_plus("setgroups");
1534
}
1535
dup2(devnull, STDIN_FILENO);
1536
close(devnull);
1537
dup2(STDERR_FILENO, STDOUT_FILENO);
1538
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1539
if(ret == -1){
1540
perror_plus("setenv");
1541
_exit(EX_OSERR);
1542
}
1543
ret = setenv("DEVICE", interface, 1);
1544
if(ret == -1){
1545
perror_plus("setenv");
1546
_exit(EX_OSERR);
1547
}
1548
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1549
if(ret == -1){
1550
perror_plus("setenv");
1551
_exit(EX_OSERR);
1552
}
1553
ret = setenv("MODE", mode, 1);
1554
if(ret == -1){
1555
perror_plus("setenv");
1556
_exit(EX_OSERR);
1557
}
1558
char *delaystring;
1559
ret = asprintf(&delaystring, "%f", delay);
1560
if(ret == -1){
1561
perror_plus("asprintf");
1562
_exit(EX_OSERR);
1563
}
1564
ret = setenv("DELAY", delaystring, 1);
1565
if(ret == -1){
1566
free(delaystring);
1567
perror_plus("setenv");
1568
_exit(EX_OSERR);
1569
}
1729
_exit(EX_OSERR);
1730
}
1731
ret = setenv("DELAY", delaystring, 1);
1732
if(ret == -1){
1570
1733
free(delaystring);
1571
if(connect_to != NULL){
1572
ret = setenv("CONNECT", connect_to, 1);
1573
if(ret == -1){
1574
perror_plus("setenv");
1575
_exit(EX_OSERR);
1576
}
1577
}
1578
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1579
perror_plus("execl");
1580
_exit(EXIT_FAILURE);
1581
}
1734
perror_plus("setenv");
1735
_exit(EX_OSERR);
1736
}
1737
free(delaystring);
1738
if(connect_to != NULL){
1739
ret = setenv("CONNECT", connect_to, 1);
1740
if(ret == -1){
1741
perror_plus("setenv");
1742
_exit(EX_OSERR);
1743
}
1744
}
1745
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
1746
if(hook_fd == -1){
1747
perror_plus("openat");
1748
_exit(EXIT_FAILURE);
1749
}
1750
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1751
perror_plus("close");
1752
_exit(EXIT_FAILURE);
1753
}
1754
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1755
environ) == -1){
1756
perror_plus("fexecve");
1757
_exit(EXIT_FAILURE);
1758
}
1759
} else {
1760
if(hook_pid == -1){
1761
perror_plus("fork");
1762
free(direntry);
1763
continue;
1764
}
1765
int status;
1766
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1767
perror_plus("waitpid");
1768
free(direntry);
1769
continue;
1770
}
1771
if(WIFEXITED(status)){
1772
if(WEXITSTATUS(status) != 0){
1773
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1774
" with status %d\n", direntry->d_name,
1775
WEXITSTATUS(status));
1776
free(direntry);
1777
continue;
1778
}
1779
} else if(WIFSIGNALED(status)){
1780
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1781
" signal %d\n", direntry->d_name,
1782
WTERMSIG(status));
1783
free(direntry);
1784
continue;
1582
1785
} else {
1583
int status;
1584
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1585
perror_plus("waitpid");
1586
free(fullname);
1587
continue;
1588
}
1589
if(WIFEXITED(status)){
1590
if(WEXITSTATUS(status) != 0){
1591
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1592
" with status %d\n", direntry->d_name,
1593
WEXITSTATUS(status));
1594
free(fullname);
1595
continue;
1596
}
1597
} else if(WIFSIGNALED(status)){
1598
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1599
" signal %d\n", direntry->d_name,
1600
WTERMSIG(status));
1601
free(fullname);
1602
continue;
1603
} else {
1604
fprintf_plus(stderr, "Warning: network hook \"%s\""
1605
" crashed\n", direntry->d_name);
1606
free(fullname);
1607
continue;
1608
}
1609
}
1610
free(fullname);
1611
if(debug){
1612
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1613
direntry->d_name);
1614
}
1615
}
1616
close(devnull);
1617
}
1618
return true;
1786
fprintf_plus(stderr, "Warning: network hook \"%s\""
1787
" crashed\n", direntry->d_name);
1788
free(direntry);
1789
continue;
1790
}
1791
}
1792
if(debug){
1793
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1794
direntry->d_name);
1795
}
1796
free(direntry);
1797
}
1798
free(direntries);
1799
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1800
perror_plus("close");
1801
} else {
1802
hookdir_fd = -1;
1803
}
1804
close(devnull);
1619
1805
}
1620
1806
1807
__attribute__((nonnull, warn_unused_result))
1621
1808
error_t bring_up_interface(const char *const interface,
1622
1809
const float delay){
1623
int sd = -1;
1624
1810
error_t old_errno = errno;
1625
error_t ret_errno = 0;
1626
int ret, ret_setflags;
1811
int ret;
1627
1812
struct ifreq network;
1628
1813
unsigned int if_index = if_nametoindex(interface);
1629
1814
if(if_index == 0){
1638
1823
}
1639
1824
1640
1825
if(not interface_is_up(interface)){
1641
if(not get_flags(interface, &network) and debug){
1826
error_t ret_errno = 0, ioctl_errno = 0;
1827
if(not get_flags(interface, &network)){
1642
1828
ret_errno = errno;
1643
1829
fprintf_plus(stderr, "Failed to get flags for interface "
1644
1830
"\"%s\"\n", interface);
1831
errno = old_errno;
1645
1832
return ret_errno;
1646
1833
}
1647
network.ifr_flags |= IFF_UP;
1834
network.ifr_flags |= IFF_UP; /* set flag */
1648
1835
1649
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1650
if(sd < 0){
1836
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1837
if(sd == -1){
1651
1838
ret_errno = errno;
1652
1839
perror_plus("socket");
1653
1840
errno = old_errno;
1654
1841
return ret_errno;
1655
1842
}
1656
1843
1657
1844
if(quit_now){
1658
close(sd);
1845
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1846
if(ret == -1){
1847
perror_plus("close");
1848
}
1659
1849
errno = old_errno;
1660
1850
return EINTR;
1661
1851
}
1665
1855
interface);
1666
1856
}
1667
1857
1668
/* Raise priviliges */
1669
raise_privileges();
1858
/* Raise privileges */
1859
ret_errno = raise_privileges();
1860
if(ret_errno != 0){
1861
errno = ret_errno;
1862
perror_plus("Failed to raise privileges");
1863
}
1670
1864
1671
1865
#ifdef __linux__
1672
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1673
messages about the network interface to mess up the prompt */
1674
int ret_linux = klogctl(8, NULL, 5);
1675
bool restore_loglevel = true;
1676
if(ret_linux == -1){
1677
restore_loglevel = false;
1678
perror_plus("klogctl");
1866
int ret_linux;
1867
bool restore_loglevel = false;
1868
if(ret_errno == 0){
1869
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1870
messages about the network interface to mess up the prompt */
1871
ret_linux = klogctl(8, NULL, 5);
1872
if(ret_linux == -1){
1873
perror_plus("klogctl");
1874
} else {
1875
restore_loglevel = true;
1876
}
1679
1877
}
1680
1878
#endif /* __linux__ */
1681
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1682
ret_errno = errno;
1879
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1880
ioctl_errno = errno;
1683
1881
#ifdef __linux__
1684
1882
if(restore_loglevel){
1685
1883
ret_linux = klogctl(7, NULL, 0);
1689
1887
}
1690
1888
#endif /* __linux__ */
1691
1889
1692
/* Lower privileges */
1693
lower_privileges();
1890
/* If raise_privileges() succeeded above */
1891
if(ret_errno == 0){
1892
/* Lower privileges */
1893
ret_errno = lower_privileges();
1894
if(ret_errno != 0){
1895
errno = ret_errno;
1896
perror_plus("Failed to lower privileges");
1897
}
1898
}
1694
1899
1695
1900
/* Close the socket */
1696
1901
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1699
1904
}
1700
1905
1701
1906
if(ret_setflags == -1){
1702
errno = ret_errno;
1907
errno = ioctl_errno;
1703
1908
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1704
1909
errno = old_errno;
1705
return ret_errno;
1910
return ioctl_errno;
1706
1911
}
1707
1912
} else if(debug){
1708
1913
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1726
1931
return 0;
1727
1932
}
1728
1933
1934
__attribute__((nonnull, warn_unused_result))
1729
1935
error_t take_down_interface(const char *const interface){
1730
int sd = -1;
1731
1936
error_t old_errno = errno;
1732
error_t ret_errno = 0;
1733
int ret, ret_setflags;
1734
1937
struct ifreq network;
1735
1938
unsigned int if_index = if_nametoindex(interface);
1736
1939
if(if_index == 0){
1739
1942
return ENXIO;
1740
1943
}
1741
1944
if(interface_is_up(interface)){
1945
error_t ret_errno = 0, ioctl_errno = 0;
1742
1946
if(not get_flags(interface, &network) and debug){
1743
1947
ret_errno = errno;
1744
1948
fprintf_plus(stderr, "Failed to get flags for interface "
1745
1949
"\"%s\"\n", interface);
1950
errno = old_errno;
1746
1951
return ret_errno;
1747
1952
}
1748
1953
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1749
1954
1750
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1751
if(sd < 0){
1955
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1956
if(sd == -1){
1752
1957
ret_errno = errno;
1753
1958
perror_plus("socket");
1754
1959
errno = old_errno;
1760
1965
interface);
1761
1966
}
1762
1967
1763
/* Raise priviliges */
1764
raise_privileges();
1765
1766
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1767
ret_errno = errno;
1768
1769
/* Lower privileges */
1770
lower_privileges();
1968
/* Raise privileges */
1969
ret_errno = raise_privileges();
1970
if(ret_errno != 0){
1971
errno = ret_errno;
1972
perror_plus("Failed to raise privileges");
1973
}
1974
1975
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1976
ioctl_errno = errno;
1977
1978
/* If raise_privileges() succeeded above */
1979
if(ret_errno == 0){
1980
/* Lower privileges */
1981
ret_errno = lower_privileges();
1982
if(ret_errno != 0){
1983
errno = ret_errno;
1984
perror_plus("Failed to lower privileges");
1985
}
1986
}
1771
1987
1772
1988
/* Close the socket */
1773
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1989
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1774
1990
if(ret == -1){
1775
1991
perror_plus("close");
1776
1992
}
1777
1993
1778
1994
if(ret_setflags == -1){
1779
errno = ret_errno;
1995
errno = ioctl_errno;
1780
1996
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1781
1997
errno = old_errno;
1782
return ret_errno;
1998
return ioctl_errno;
1783
1999
}
1784
2000
} else if(debug){
1785
2001
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1791
2007
}
1792
2008
1793
2009
int main(int argc, char *argv[]){
1794
mandos_context mc = { .server = NULL, .dh_bits = 1024,
2010
mandos_context mc = { .server = NULL, .dh_bits = 0,
1795
2011
.priority = "SECURE256:!CTYPE-X.509:"
1796
"+CTYPE-OPENPGP", .current_server = NULL,
2012
"+CTYPE-OPENPGP:!RSA", .current_server = NULL,
1797
2013
.interfaces = NULL, .interfaces_size = 0 };
1798
2014
AvahiSServiceBrowser *sb = NULL;
1799
2015
error_t ret_errno;
1803
2019
int exitcode = EXIT_SUCCESS;
1804
2020
char *interfaces_to_take_down = NULL;
1805
2021
size_t interfaces_to_take_down_size = 0;
1806
char tempdir[] = "/tmp/mandosXXXXXX";
1807
bool tempdir_created = false;
2022
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2023
char old_tempdir[] = "/tmp/mandosXXXXXX";
2024
char *tempdir = NULL;
1808
2025
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1809
2026
const char *seckey = PATHDIR "/" SECKEY;
1810
2027
const char *pubkey = PATHDIR "/" PUBKEY;
1811
2028
char *interfaces_hooks = NULL;
1812
size_t interfaces_hooks_size = 0;
1813
2029
1814
2030
bool gnutls_initialized = false;
1815
2031
bool gpgme_initialized = false;
1993
2209
/* Work around Debian bug #633582:
1994
2210
<http://bugs.debian.org/633582> */
1995
2211
1996
/* Re-raise priviliges */
1997
if(raise_privileges() == 0){
2212
/* Re-raise privileges */
2213
ret_errno = raise_privileges();
2214
if(ret_errno != 0){
2215
errno = ret_errno;
2216
perror_plus("Failed to raise privileges");
2217
} else {
1998
2218
struct stat st;
1999
2219
2000
2220
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2040
2260
}
2041
2261
2042
2262
/* Lower privileges */
2043
lower_privileges();
2263
ret_errno = lower_privileges();
2264
if(ret_errno != 0){
2265
errno = ret_errno;
2266
perror_plus("Failed to lower privileges");
2267
}
2044
2268
}
2045
2269
}
2046
2270
2070
2294
goto end;
2071
2295
}
2072
2296
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2073
interfaces_hooks_size = mc.interfaces_size;
2074
argz_stringify(interfaces_hooks, interfaces_hooks_size,
2075
(int)',');
2076
}
2077
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2078
interfaces_hooks : "", delay)){
2079
goto end;
2080
}
2297
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2298
}
2299
run_network_hooks("start", interfaces_hooks != NULL ?
2300
interfaces_hooks : "", delay);
2081
2301
}
2082
2302
2083
2303
if(not debug){
2161
2381
2162
2382
/* If no interfaces were specified, make a list */
2163
2383
if(mc.interfaces == NULL){
2164
struct dirent **direntries;
2384
struct dirent **direntries = NULL;
2165
2385
/* Look for any good interfaces */
2166
2386
ret = scandir(sys_class_net, &direntries, good_interface,
2167
2387
alphasort);
2171
2391
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2172
2392
direntries[i]->d_name);
2173
2393
if(ret_errno != 0){
2394
errno = ret_errno;
2174
2395
perror_plus("argz_add");
2396
free(direntries[i]);
2175
2397
continue;
2176
2398
}
2177
2399
if(debug){
2178
2400
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2179
2401
direntries[i]->d_name);
2180
2402
}
2403
free(direntries[i]);
2181
2404
}
2182
2405
free(direntries);
2183
2406
} else {
2184
free(direntries);
2407
if(ret == 0){
2408
free(direntries);
2409
}
2185
2410
fprintf_plus(stderr, "Could not find a network interface\n");
2186
2411
exitcode = EXIT_FAILURE;
2187
2412
goto end;
2210
2435
break;
2211
2436
}
2212
2437
bool interface_was_up = interface_is_up(interface);
2213
ret = bring_up_interface(interface, delay);
2438
errno = bring_up_interface(interface, delay);
2214
2439
if(not interface_was_up){
2215
if(ret != 0){
2216
errno = ret;
2440
if(errno != 0){
2217
2441
perror_plus("Failed to bring up interface");
2218
2442
} else {
2219
ret_errno = argz_add(&interfaces_to_take_down,
2220
&interfaces_to_take_down_size,
2221
interface);
2443
errno = argz_add(&interfaces_to_take_down,
2444
&interfaces_to_take_down_size,
2445
interface);
2446
if(errno != 0){
2447
perror_plus("argz_add");
2448
}
2222
2449
}
2223
2450
}
2224
2451
}
2253
2480
goto end;
2254
2481
}
2255
2482
2256
if(mkdtemp(tempdir) == NULL){
2483
/* Try /run/tmp before /tmp */
2484
tempdir = mkdtemp(run_tempdir);
2485
if(tempdir == NULL and errno == ENOENT){
2486
if(debug){
2487
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2488
run_tempdir, old_tempdir);
2489
}
2490
tempdir = mkdtemp(old_tempdir);
2491
}
2492
if(tempdir == NULL){
2257
2493
perror_plus("mkdtemp");
2258
2494
goto end;
2259
2495
}
2260
tempdir_created = true;
2261
2496
2262
2497
if(quit_now){
2263
2498
goto end;
2338
2573
sleep((unsigned int)retry_interval);
2339
2574
}
2340
2575
2341
if (not quit_now){
2576
if(not quit_now){
2342
2577
exitcode = EXIT_SUCCESS;
2343
2578
}
2344
2579
2399
2634
if(debug){
2400
2635
fprintf_plus(stderr, "Starting Avahi loop search\n");
2401
2636
}
2402
2637
2403
2638
ret = avahi_loop_with_timeout(simple_poll,
2404
2639
(int)(retry_interval * 1000), &mc);
2405
2640
if(debug){
2441
2676
mc.current_server->prev->next = NULL;
2442
2677
while(mc.current_server != NULL){
2443
2678
server *next = mc.current_server->next;
2679
#ifdef __GNUC__
2680
#pragma GCC diagnostic push
2681
#pragma GCC diagnostic ignored "-Wcast-qual"
2682
#endif
2683
free((char *)(mc.current_server->ip));
2684
#ifdef __GNUC__
2685
#pragma GCC diagnostic pop
2686
#endif
2444
2687
free(mc.current_server);
2445
2688
mc.current_server = next;
2446
2689
}
2447
2690
}
2448
2691
2449
/* Re-raise priviliges */
2692
/* Re-raise privileges */
2450
2693
{
2451
raise_privileges();
2452
2453
/* Run network hooks */
2454
run_network_hooks("stop", interfaces_hooks != NULL ?
2455
interfaces_hooks : "", delay);
2456
2457
/* Take down the network interfaces which were brought up */
2458
{
2459
char *interface = NULL;
2460
while((interface=argz_next(interfaces_to_take_down,
2461
interfaces_to_take_down_size,
2462
interface))){
2463
ret_errno = take_down_interface(interface);
2464
if(ret_errno != 0){
2465
errno = ret_errno;
2466
perror_plus("Failed to take down interface");
2467
}
2468
}
2469
if(debug and (interfaces_to_take_down == NULL)){
2470
fprintf_plus(stderr, "No interfaces needed to be taken"
2471
" down\n");
2472
}
2473
}
2474
2475
lower_privileges_permanently();
2694
ret_errno = raise_privileges();
2695
if(ret_errno != 0){
2696
errno = ret_errno;
2697
perror_plus("Failed to raise privileges");
2698
} else {
2699
2700
/* Run network hooks */
2701
run_network_hooks("stop", interfaces_hooks != NULL ?
2702
interfaces_hooks : "", delay);
2703
2704
/* Take down the network interfaces which were brought up */
2705
{
2706
char *interface = NULL;
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;
2713
perror_plus("Failed to take down interface");
2714
}
2715
}
2716
if(debug and (interfaces_to_take_down == NULL)){
2717
fprintf_plus(stderr, "No interfaces needed to be taken"
2718
" down\n");
2719
}
2720
}
2721
}
2722
2723
ret_errno = lower_privileges_permanently();
2724
if(ret_errno != 0){
2725
errno = ret_errno;
2726
perror_plus("Failed to lower privileges permanently");
2727
}
2476
2728
}
2477
2729
2478
2730
free(interfaces_to_take_down);
2479
2731
free(interfaces_hooks);
2480
2732
2481
2733
/* Removes the GPGME temp directory and all files inside */
2482
if(tempdir_created){
2734
if(tempdir != NULL){
2483
2735
struct dirent **direntries = NULL;
2484
struct dirent *direntry = NULL;
2485
int numentries = scandir(tempdir, &direntries, notdotentries,
2486
alphasort);
2487
if (numentries > 0){
2488
for(int i = 0; i < numentries; i++){
2489
direntry = direntries[i];
2490
char *fullname = NULL;
2491
ret = asprintf(&fullname, "%s/%s", tempdir,
2492
direntry->d_name);
2493
if(ret < 0){
2494
perror_plus("asprintf");
2495
continue;
2496
}
2497
ret = remove(fullname);
2498
if(ret == -1){
2499
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2500
strerror(errno));
2501
}
2502
free(fullname);
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
}
2503
2773
}
2504
}
2505
2506
/* need to clean even if 0 because man page doesn't specify */
2507
free(direntries);
2508
if (numentries == -1){
2509
perror_plus("scandir");
2510
}
2511
ret = rmdir(tempdir);
2512
if(ret == -1 and errno != ENOENT){
2513
perror_plus("rmdir");
2774
TEMP_FAILURE_RETRY(close(tempdir_fd));
2514
2775
}
2515
2776
}
2516
2777
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0