(root)/mandos/release
» Revision
237.24.1
(compared to revision 237.16.10)
: plugins.d/mandos-client.c
To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 237.24.1
- compare with another revision
- download diff
- download tarball
- view history from revision 237.24.1
- Committer: Teddy Hogeborn
- Date: 2015-05-23 20:18:34 UTC
- mto: (237.7.304 trunk)
- mto: This revision was merged to the branch mainline in revision 325.
- 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/mandos-client.examples
- debian/upstream
- files modified:
- .bzrignore
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-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 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() */
44
#include <stdint.h> /* uint16_t, uint32_t */
43
stdout, ferror() */
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(),
47
47
strtof(), abort() */
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,
63
64
strtoimax() */
64
#include <assert.h> /* assert() */
65
65
#include <errno.h> /* perror(), errno,
66
66
program_invocation_short_name */
67
67
#include <time.h> /* nanosleep(), time(), sleep() */
73
73
*/
74
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
75
getuid(), getgid(), seteuid(),
76
setgid(), pause() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
76
setgid(), pause(), _exit(),
77
unlinkat() */
78
#include <arpa/inet.h> /* inet_pton(), htons() */
78
79
#include <iso646.h> /* not, or, and */
79
80
#include <argp.h> /* struct argp_option, error_t, struct
80
81
argp_state, struct argp,
87
88
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
89
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
90
WEXITSTATUS(), WTERMSIG() */
91
#include <grp.h> /* setgroups() */
92
#include <argz.h> /* argz_add_sep(), argz_next(),
93
argz_delete(), argz_append(),
94
argz_stringify(), argz_add(),
95
argz_count() */
96
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
97
EAI_SYSTEM, gai_strerror() */
90
98
91
99
#ifdef __linux__
92
100
#include <sys/klog.h> /* klogctl() */
134
142
static const char sys_class_net[] = "/sys/class/net";
135
143
char *connect_to = NULL;
136
144
const char *hookdir = HOOKDIR;
145
int hookdir_fd = -1;
146
uid_t uid = 65534;
147
gid_t gid = 65534;
137
148
138
149
/* Doubly linked list that need to be circularly linked when used */
139
150
typedef struct server{
140
151
const char *ip;
141
uint16_t port;
152
in_port_t port;
142
153
AvahiIfIndex if_index;
143
154
int af;
144
155
struct timespec last_seen;
148
159
149
160
/* Used for passing in values through the Avahi callback functions */
150
161
typedef struct {
151
AvahiSimplePoll *simple_poll;
152
162
AvahiServer *server;
153
163
gnutls_certificate_credentials_t cred;
154
164
unsigned int dh_bits;
156
166
const char *priority;
157
167
gpgme_ctx_t ctx;
158
168
server *current_server;
169
char *interfaces;
170
size_t interfaces_size;
159
171
} mandos_context;
160
172
161
/* global context so signal handler can reach it*/
162
mandos_context mc = { .simple_poll = NULL, .server = NULL,
163
.dh_bits = 1024, .priority = "SECURE256"
164
":!CTYPE-X.509:+CTYPE-OPENPGP",
165
.current_server = NULL };
173
/* global so signal handler can reach it*/
174
AvahiSimplePoll *simple_poll;
166
175
167
176
sig_atomic_t quit_now = 0;
168
177
int signal_received = 0;
169
178
170
179
/* Function to use when printing errors */
171
180
void perror_plus(const char *print_text){
181
int e = errno;
172
182
fprintf(stderr, "Mandos plugin %s: ",
173
183
program_invocation_short_name);
184
errno = e;
174
185
perror(print_text);
175
186
}
176
187
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
177
189
int fprintf_plus(FILE *stream, const char *format, ...){
178
190
va_list ap;
179
191
va_start (ap, format);
180
192
181
193
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
182
194
program_invocation_short_name));
183
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
195
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
184
196
}
185
197
186
198
/*
188
200
* bytes. "buffer_capacity" is how much is currently allocated,
189
201
* "buffer_length" is how much is already used.
190
202
*/
203
__attribute__((nonnull, warn_unused_result))
191
204
size_t incbuffer(char **buffer, size_t buffer_length,
192
205
size_t buffer_capacity){
193
206
if(buffer_length + BUFFER_SIZE > buffer_capacity){
194
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
195
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;
196
213
return 0;
197
214
}
215
*buffer = new_buf;
198
216
buffer_capacity += BUFFER_SIZE;
199
217
}
200
218
return buffer_capacity;
201
219
}
202
220
203
221
/* Add server to set of servers to retry periodically */
204
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
205
int af){
222
__attribute__((nonnull, warn_unused_result))
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
224
int af, server **current_server){
206
225
int ret;
207
226
server *new_server = malloc(sizeof(server));
208
227
if(new_server == NULL){
209
228
perror_plus("malloc");
210
return -1;
229
return false;
211
230
}
212
231
*new_server = (server){ .ip = strdup(ip),
213
232
.port = port,
215
234
.af = af };
216
235
if(new_server->ip == NULL){
217
236
perror_plus("strdup");
218
return -1;
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);
252
return false;
219
253
}
220
254
/* Special case of first server */
221
if (mc.current_server == NULL){
255
if(*current_server == NULL){
222
256
new_server->next = new_server;
223
257
new_server->prev = new_server;
224
mc.current_server = new_server;
225
/* Place the new server last in the list */
258
*current_server = new_server;
226
259
} else {
227
new_server->next = mc.current_server;
228
new_server->prev = mc.current_server->prev;
260
/* Place the new server last in the list */
261
new_server->next = *current_server;
262
new_server->prev = (*current_server)->prev;
229
263
new_server->prev->next = new_server;
230
mc.current_server->prev = new_server;
231
}
232
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
233
if(ret == -1){
234
perror_plus("clock_gettime");
235
return -1;
236
}
237
return 0;
264
(*current_server)->prev = new_server;
265
}
266
return true;
238
267
}
239
268
240
269
/*
241
270
* Initialize GPGME.
242
271
*/
243
static bool init_gpgme(const char *seckey, const char *pubkey,
244
const char *tempdir){
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){
245
277
gpgme_error_t rc;
246
278
gpgme_engine_info_t engine_info;
247
279
248
249
280
/*
250
281
* Helper function to insert pub and seckey to the engine keyring.
251
282
*/
252
bool import_key(const char *filename){
283
bool import_key(const char * const filename){
253
284
int ret;
254
285
int fd;
255
286
gpgme_data_t pgp_data;
267
298
return false;
268
299
}
269
300
270
rc = gpgme_op_import(mc.ctx, pgp_data);
301
rc = gpgme_op_import(mc->ctx, pgp_data);
271
302
if(rc != GPG_ERR_NO_ERROR){
272
303
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
273
304
gpgme_strsource(rc), gpgme_strerror(rc));
317
348
}
318
349
319
350
/* Create new GPGME "context" */
320
rc = gpgme_new(&(mc.ctx));
351
rc = gpgme_new(&(mc->ctx));
321
352
if(rc != GPG_ERR_NO_ERROR){
322
353
fprintf_plus(stderr, "Mandos plugin mandos-client: "
323
354
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
336
367
* Decrypt OpenPGP data.
337
368
* Returns -1 on error
338
369
*/
370
__attribute__((nonnull, warn_unused_result))
339
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
340
372
size_t crypto_size,
341
char **plaintext){
373
char **plaintext,
374
mandos_context *mc){
342
375
gpgme_data_t dh_crypto, dh_plain;
343
376
gpgme_error_t rc;
344
377
ssize_t ret;
370
403
371
404
/* Decrypt data from the cryptotext data buffer to the plaintext
372
405
data buffer */
373
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
406
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
374
407
if(rc != GPG_ERR_NO_ERROR){
375
408
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
376
409
gpgme_strsource(rc), gpgme_strerror(rc));
377
410
plaintext_length = -1;
378
411
if(debug){
379
412
gpgme_decrypt_result_t result;
380
result = gpgme_op_decrypt_result(mc.ctx);
413
result = gpgme_op_decrypt_result(mc->ctx);
381
414
if(result == NULL){
382
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
383
416
} else {
460
493
return plaintext_length;
461
494
}
462
495
463
static const char * safer_gnutls_strerror(int value){
464
const char *ret = gnutls_strerror(value); /* Spurious warning from
465
-Wunreachable-code */
466
if(ret == NULL)
467
ret = "(unknown)";
468
return ret;
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){
505
const char *ret = gnutls_strerror(value);
506
return safe_string(ret);
469
507
}
470
508
471
509
/* GnuTLS log function callback */
510
__attribute__((nonnull))
472
511
static void debuggnutls(__attribute__((unused)) int level,
473
512
const char* string){
474
513
fprintf_plus(stderr, "GnuTLS: %s", string);
475
514
}
476
515
516
__attribute__((nonnull, warn_unused_result))
477
517
static int init_gnutls_global(const char *pubkeyfilename,
478
const char *seckeyfilename){
518
const char *seckeyfilename,
519
mandos_context *mc){
479
520
int ret;
521
unsigned int uret;
480
522
481
523
if(debug){
482
524
fprintf_plus(stderr, "Initializing GnuTLS\n");
498
540
}
499
541
500
542
/* OpenPGP credentials */
501
ret = gnutls_certificate_allocate_credentials(&mc.cred);
543
ret = gnutls_certificate_allocate_credentials(&mc->cred);
502
544
if(ret != GNUTLS_E_SUCCESS){
503
545
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
504
546
safer_gnutls_strerror(ret));
514
556
}
515
557
516
558
ret = gnutls_certificate_set_openpgp_key_file
517
(mc.cred, pubkeyfilename, seckeyfilename,
559
(mc->cred, pubkeyfilename, seckeyfilename,
518
560
GNUTLS_OPENPGP_FMT_BASE64);
519
561
if(ret != GNUTLS_E_SUCCESS){
520
562
fprintf_plus(stderr,
526
568
}
527
569
528
570
/* GnuTLS server initialization */
529
ret = gnutls_dh_params_init(&mc.dh_params);
571
ret = gnutls_dh_params_init(&mc->dh_params);
530
572
if(ret != GNUTLS_E_SUCCESS){
531
573
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
532
574
" initialization: %s\n",
533
575
safer_gnutls_strerror(ret));
534
576
goto globalfail;
535
577
}
536
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
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
}
679
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
537
680
if(ret != GNUTLS_E_SUCCESS){
538
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
539
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));
540
683
goto globalfail;
541
684
}
542
685
543
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
686
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
544
687
545
688
return 0;
546
689
547
690
globalfail:
548
691
549
gnutls_certificate_free_credentials(mc.cred);
692
gnutls_certificate_free_credentials(mc->cred);
550
693
gnutls_global_deinit();
551
gnutls_dh_params_deinit(mc.dh_params);
694
gnutls_dh_params_deinit(mc->dh_params);
552
695
return -1;
553
696
}
554
697
555
static int init_gnutls_session(gnutls_session_t *session){
698
__attribute__((nonnull, warn_unused_result))
699
static int init_gnutls_session(gnutls_session_t *session,
700
mandos_context *mc){
556
701
int ret;
557
702
/* GnuTLS session creation */
558
703
do {
570
715
{
571
716
const char *err;
572
717
do {
573
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
718
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
574
719
if(quit_now){
575
720
gnutls_deinit(*session);
576
721
return -1;
587
732
588
733
do {
589
734
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
590
mc.cred);
735
mc->cred);
591
736
if(quit_now){
592
737
gnutls_deinit(*session);
593
738
return -1;
603
748
/* ignore client certificate if any. */
604
749
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
605
750
606
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
751
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
607
752
608
753
return 0;
609
754
}
613
758
__attribute__((unused)) const char *txt){}
614
759
615
760
/* Called when a Mandos server is found */
616
static int start_mandos_communication(const char *ip, uint16_t port,
761
__attribute__((nonnull, warn_unused_result))
762
static int start_mandos_communication(const char *ip, in_port_t port,
617
763
AvahiIfIndex if_index,
618
int af){
764
int af, mandos_context *mc){
619
765
int ret, tcp_sd = -1;
620
766
ssize_t sret;
621
union {
622
struct sockaddr_in in;
623
struct sockaddr_in6 in6;
624
} to;
767
struct sockaddr_storage to;
625
768
char *buffer = NULL;
626
769
char *decrypted_buffer = NULL;
627
770
size_t buffer_length = 0;
651
794
return -1;
652
795
}
653
796
654
ret = init_gnutls_session(&session);
797
/* If the interface is specified and we have a list of interfaces */
798
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
799
/* Check if the interface is one of the interfaces we are using */
800
bool match = false;
801
{
802
char *interface = NULL;
803
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
804
interface))){
805
if(if_nametoindex(interface) == (unsigned int)if_index){
806
match = true;
807
break;
808
}
809
}
810
}
811
if(not match){
812
/* This interface does not match any in the list, so we don't
813
connect to the server */
814
if(debug){
815
char interface[IF_NAMESIZE];
816
if(if_indextoname((unsigned int)if_index, interface) == NULL){
817
perror_plus("if_indextoname");
818
} else {
819
fprintf_plus(stderr, "Skipping server on non-used interface"
820
" \"%s\"\n",
821
if_indextoname((unsigned int)if_index,
822
interface));
823
}
824
}
825
return -1;
826
}
827
}
828
829
ret = init_gnutls_session(&session, mc);
655
830
if(ret != 0){
656
831
return -1;
657
832
}
658
833
659
834
if(debug){
660
835
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
661
PRIu16 "\n", ip, port);
836
PRIuMAX "\n", ip, (uintmax_t)port);
662
837
}
663
838
664
839
tcp_sd = socket(pf, SOCK_STREAM, 0);
676
851
677
852
memset(&to, 0, sizeof(to));
678
853
if(af == AF_INET6){
679
to.in6.sin6_family = (sa_family_t)af;
680
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);
681
856
} else { /* IPv4 */
682
to.in.sin_family = (sa_family_t)af;
683
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);
684
859
}
685
860
if(ret < 0 ){
686
861
int e = errno;
695
870
goto mandos_end;
696
871
}
697
872
if(af == AF_INET6){
698
to.in6.sin6_port = htons(port); /* Spurious warnings from
699
-Wconversion and
700
-Wunreachable-code */
701
702
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
703
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
704
-Wunreachable-code*/
873
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
874
if(IN6_IS_ADDR_LINKLOCAL
875
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
705
876
if(if_index == AVAHI_IF_UNSPEC){
706
877
fprintf_plus(stderr, "An IPv6 link-local address is"
707
878
" incomplete without a network interface\n");
709
880
goto mandos_end;
710
881
}
711
882
/* Set the network interface number as scope */
712
to.in6.sin6_scope_id = (uint32_t)if_index;
883
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
713
884
}
714
885
} else {
715
to.in.sin_port = htons(port); /* Spurious warnings from
716
-Wconversion and
717
-Wunreachable-code */
886
((struct sockaddr_in *)&to)->sin_port = htons(port);
718
887
}
719
888
720
889
if(quit_now){
728
897
if(if_indextoname((unsigned int)if_index, interface) == NULL){
729
898
perror_plus("if_indextoname");
730
899
} else {
731
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
732
"\n", ip, interface, port);
900
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
901
"\n", ip, interface, (uintmax_t)port);
733
902
}
734
903
} else {
735
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
736
ip, port);
904
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
905
ip, (uintmax_t)port);
737
906
}
738
907
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
739
908
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
740
const char *pcret;
741
909
if(af == AF_INET6){
742
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
743
sizeof(addrstr));
910
ret = getnameinfo((struct sockaddr *)&to,
911
sizeof(struct sockaddr_in6),
912
addrstr, sizeof(addrstr), NULL, 0,
913
NI_NUMERICHOST);
744
914
} else {
745
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
746
sizeof(addrstr));
915
ret = getnameinfo((struct sockaddr *)&to,
916
sizeof(struct sockaddr_in),
917
addrstr, sizeof(addrstr), NULL, 0,
918
NI_NUMERICHOST);
747
919
}
748
if(pcret == NULL){
749
perror_plus("inet_ntop");
750
} else {
751
if(strcmp(addrstr, ip) != 0){
752
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
753
}
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);
754
926
}
755
927
}
756
928
760
932
}
761
933
762
934
if(af == AF_INET6){
763
ret = connect(tcp_sd, &to.in6, sizeof(to));
935
ret = connect(tcp_sd, (struct sockaddr *)&to,
936
sizeof(struct sockaddr_in6));
764
937
} else {
765
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
938
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
939
sizeof(struct sockaddr_in));
766
940
}
767
941
if(ret < 0){
768
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
942
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
769
943
int e = errno;
770
944
perror_plus("connect");
771
945
errno = e;
817
991
goto mandos_end;
818
992
}
819
993
820
/* Spurious warning from -Wint-to-pointer-cast */
821
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
994
/* This casting via intptr_t is to eliminate warning about casting
995
an int to a pointer type. This is exactly how the GnuTLS Guile
996
function "set-session-transport-fd!" does it. */
997
gnutls_transport_set_ptr(session,
998
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
822
999
823
1000
if(quit_now){
824
1001
errno = EINTR;
929
1106
if(buffer_length > 0){
930
1107
ssize_t decrypted_buffer_size;
931
1108
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
932
&decrypted_buffer);
1109
&decrypted_buffer, mc);
933
1110
if(decrypted_buffer_size >= 0){
934
1111
935
1112
written = 0;
983
1160
return retval;
984
1161
}
985
1162
1163
__attribute__((nonnull))
986
1164
static void resolve_callback(AvahiSServiceResolver *r,
987
1165
AvahiIfIndex interface,
988
1166
AvahiProtocol proto,
996
1174
AVAHI_GCC_UNUSED AvahiStringList *txt,
997
1175
AVAHI_GCC_UNUSED AvahiLookupResultFlags
998
1176
flags,
999
AVAHI_GCC_UNUSED void* userdata){
1000
assert(r);
1177
void *mc){
1178
if(r == NULL){
1179
return;
1180
}
1001
1181
1002
1182
/* Called whenever a service has been resolved successfully or
1003
1183
timed out */
1004
1184
1005
1185
if(quit_now){
1186
avahi_s_service_resolver_free(r);
1006
1187
return;
1007
1188
}
1008
1189
1012
1193
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1013
1194
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1014
1195
domain,
1015
avahi_strerror(avahi_server_errno(mc.server)));
1196
avahi_strerror(avahi_server_errno
1197
(((mandos_context*)mc)->server)));
1016
1198
break;
1017
1199
1018
1200
case AVAHI_RESOLVER_FOUND:
1024
1206
PRIdMAX ") on port %" PRIu16 "\n", name,
1025
1207
host_name, ip, (intmax_t)interface, port);
1026
1208
}
1027
int ret = start_mandos_communication(ip, port, interface,
1028
avahi_proto_to_af(proto));
1209
int ret = start_mandos_communication(ip, (in_port_t)port,
1210
interface,
1211
avahi_proto_to_af(proto),
1212
mc);
1029
1213
if(ret == 0){
1030
avahi_simple_poll_quit(mc.simple_poll);
1214
avahi_simple_poll_quit(simple_poll);
1031
1215
} else {
1032
ret = add_server(ip, port, interface,
1033
avahi_proto_to_af(proto));
1216
if(not add_server(ip, (in_port_t)port, interface,
1217
avahi_proto_to_af(proto),
1218
&((mandos_context*)mc)->current_server)){
1219
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1220
" list\n", name);
1221
}
1034
1222
}
1035
1223
}
1036
1224
}
1046
1234
const char *domain,
1047
1235
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1048
1236
flags,
1049
AVAHI_GCC_UNUSED void* userdata){
1050
assert(b);
1237
void *mc){
1238
if(b == NULL){
1239
return;
1240
}
1051
1241
1052
1242
/* Called whenever a new services becomes available on the LAN or
1053
1243
is removed from the LAN */
1061
1251
case AVAHI_BROWSER_FAILURE:
1062
1252
1063
1253
fprintf_plus(stderr, "(Avahi browser) %s\n",
1064
avahi_strerror(avahi_server_errno(mc.server)));
1065
avahi_simple_poll_quit(mc.simple_poll);
1254
avahi_strerror(avahi_server_errno
1255
(((mandos_context*)mc)->server)));
1256
avahi_simple_poll_quit(simple_poll);
1066
1257
return;
1067
1258
1068
1259
case AVAHI_BROWSER_NEW:
1071
1262
the callback function is called the Avahi server will free the
1072
1263
resolver for us. */
1073
1264
1074
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1075
name, type, domain, protocol, 0,
1076
resolve_callback, NULL) == NULL)
1265
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1266
interface, protocol, name, type,
1267
domain, protocol, 0,
1268
resolve_callback, mc) == NULL)
1077
1269
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1078
1270
" %s\n", name,
1079
avahi_strerror(avahi_server_errno(mc.server)));
1271
avahi_strerror(avahi_server_errno
1272
(((mandos_context*)mc)->server)));
1080
1273
break;
1081
1274
1082
1275
case AVAHI_BROWSER_REMOVE:
1101
1294
signal_received = sig;
1102
1295
int old_errno = errno;
1103
1296
/* set main loop to exit */
1104
if(mc.simple_poll != NULL){
1105
avahi_simple_poll_quit(mc.simple_poll);
1297
if(simple_poll != NULL){
1298
avahi_simple_poll_quit(simple_poll);
1106
1299
}
1107
1300
errno = old_errno;
1108
1301
}
1109
1302
1303
__attribute__((nonnull, warn_unused_result))
1110
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1111
1305
int ret;
1306
error_t ret_errno;
1112
1307
1113
1308
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1114
1309
if(s < 0){
1310
ret_errno = errno;
1115
1311
perror_plus("socket");
1312
errno = ret_errno;
1116
1313
return false;
1117
1314
}
1118
1315
strcpy(ifr->ifr_name, ifname);
1119
1316
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1120
1317
if(ret == -1){
1121
1318
if(debug){
1319
ret_errno = errno;
1122
1320
perror_plus("ioctl SIOCGIFFLAGS");
1321
errno = ret_errno;
1123
1322
}
1124
1323
return false;
1125
1324
}
1126
1325
return true;
1127
1326
}
1128
1327
1328
__attribute__((nonnull, warn_unused_result))
1129
1329
bool good_flags(const char *ifname, const struct ifreq *ifr){
1130
1330
1131
1331
/* Reject the loopback device */
1173
1373
* corresponds to an acceptable network device.
1174
1374
* (This function is passed to scandir(3) as a filter function.)
1175
1375
*/
1376
__attribute__((nonnull, warn_unused_result))
1176
1377
int good_interface(const struct dirent *if_entry){
1177
1378
if(if_entry->d_name[0] == '.'){
1178
1379
return 0;
1194
1395
}
1195
1396
1196
1397
/*
1197
* This function determines if a directory entry in /sys/class/net
1198
* corresponds to an acceptable network device which is up.
1199
* (This function is passed to scandir(3) as a filter function.)
1200
*/
1201
int up_interface(const struct dirent *if_entry){
1202
if(if_entry->d_name[0] == '.'){
1203
return 0;
1204
}
1205
1206
struct ifreq ifr;
1207
if(not get_flags(if_entry->d_name, &ifr)){
1208
if(debug){
1209
fprintf_plus(stderr, "Failed to get flags for interface "
1210
"\"%s\"\n", if_entry->d_name);
1211
}
1212
return 0;
1213
}
1214
1215
/* Reject down interfaces */
1216
if(not (ifr.ifr_flags & IFF_UP)){
1217
if(debug){
1218
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1219
if_entry->d_name);
1220
}
1221
return 0;
1222
}
1223
1224
/* Reject non-running interfaces */
1225
if(not (ifr.ifr_flags & IFF_RUNNING)){
1226
if(debug){
1227
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1228
if_entry->d_name);
1229
}
1230
return 0;
1231
}
1232
1233
if(not good_flags(if_entry->d_name, &ifr)){
1234
return 0;
1235
}
1236
return 1;
1237
}
1238
1398
* This function determines if a network interface is up.
1399
*/
1400
__attribute__((nonnull, warn_unused_result))
1401
bool interface_is_up(const char *interface){
1402
struct ifreq ifr;
1403
if(not get_flags(interface, &ifr)){
1404
if(debug){
1405
fprintf_plus(stderr, "Failed to get flags for interface "
1406
"\"%s\"\n", interface);
1407
}
1408
return false;
1409
}
1410
1411
return (bool)(ifr.ifr_flags & IFF_UP);
1412
}
1413
1414
/*
1415
* This function determines if a network interface is running
1416
*/
1417
__attribute__((nonnull, warn_unused_result))
1418
bool interface_is_running(const char *interface){
1419
struct ifreq ifr;
1420
if(not get_flags(interface, &ifr)){
1421
if(debug){
1422
fprintf_plus(stderr, "Failed to get flags for interface "
1423
"\"%s\"\n", interface);
1424
}
1425
return false;
1426
}
1427
1428
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1429
}
1430
1431
__attribute__((nonnull, pure, warn_unused_result))
1239
1432
int notdotentries(const struct dirent *direntry){
1240
1433
/* Skip "." and ".." */
1241
1434
if(direntry->d_name[0] == '.'
1248
1441
}
1249
1442
1250
1443
/* Is this directory entry a runnable program? */
1444
__attribute__((nonnull, warn_unused_result))
1251
1445
int runnable_hook(const struct dirent *direntry){
1252
1446
int ret;
1253
1447
size_t sret;
1261
1455
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1262
1456
"abcdefghijklmnopqrstuvwxyz"
1263
1457
"0123456789"
1264
"_-");
1458
"_.-");
1265
1459
if((direntry->d_name)[sret] != '\0'){
1266
1460
/* Contains non-allowed characters */
1267
1461
if(debug){
1271
1465
return 0;
1272
1466
}
1273
1467
1274
char *fullname = NULL;
1275
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1276
if(ret < 0){
1277
perror_plus("asprintf");
1278
return 0;
1279
}
1280
1281
ret = stat(fullname, &st);
1468
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1282
1469
if(ret == -1){
1283
1470
if(debug){
1284
1471
perror_plus("Could not stat hook");
1301
1488
}
1302
1489
return 0;
1303
1490
}
1491
if(debug){
1492
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1493
direntry->d_name);
1494
}
1304
1495
return 1;
1305
1496
}
1306
1497
1307
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1498
__attribute__((nonnull, warn_unused_result))
1499
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1500
mandos_context *mc){
1308
1501
int ret;
1309
1502
struct timespec now;
1310
1503
struct timespec waited_time;
1311
1504
intmax_t block_time;
1312
1505
1313
1506
while(true){
1314
if(mc.current_server == NULL){
1315
if (debug){
1507
if(mc->current_server == NULL){
1508
if(debug){
1316
1509
fprintf_plus(stderr, "Wait until first server is found."
1317
1510
" No timeout!\n");
1318
1511
}
1319
1512
ret = avahi_simple_poll_iterate(s, -1);
1320
1513
} else {
1321
if (debug){
1514
if(debug){
1322
1515
fprintf_plus(stderr, "Check current_server if we should run"
1323
1516
" it, or wait\n");
1324
1517
}
1331
1524
/* Calculating in ms how long time between now and server
1332
1525
who we visted longest time ago. Now - last seen. */
1333
1526
waited_time.tv_sec = (now.tv_sec
1334
- mc.current_server->last_seen.tv_sec);
1527
- mc->current_server->last_seen.tv_sec);
1335
1528
waited_time.tv_nsec = (now.tv_nsec
1336
- mc.current_server->last_seen.tv_nsec);
1529
- mc->current_server->last_seen.tv_nsec);
1337
1530
/* total time is 10s/10,000ms.
1338
1531
Converting to s from ms by dividing by 1,000,
1339
1532
and ns to ms by dividing by 1,000,000. */
1341
1534
- ((intmax_t)waited_time.tv_sec * 1000))
1342
1535
- ((intmax_t)waited_time.tv_nsec / 1000000));
1343
1536
1344
if (debug){
1537
if(debug){
1345
1538
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1346
1539
block_time);
1347
1540
}
1348
1541
1349
1542
if(block_time <= 0){
1350
ret = start_mandos_communication(mc.current_server->ip,
1351
mc.current_server->port,
1352
mc.current_server->if_index,
1353
mc.current_server->af);
1543
ret = start_mandos_communication(mc->current_server->ip,
1544
mc->current_server->port,
1545
mc->current_server->if_index,
1546
mc->current_server->af, mc);
1354
1547
if(ret == 0){
1355
avahi_simple_poll_quit(mc.simple_poll);
1548
avahi_simple_poll_quit(s);
1356
1549
return 0;
1357
1550
}
1358
1551
ret = clock_gettime(CLOCK_MONOTONIC,
1359
&mc.current_server->last_seen);
1552
&mc->current_server->last_seen);
1360
1553
if(ret == -1){
1361
1554
perror_plus("clock_gettime");
1362
1555
return -1;
1363
1556
}
1364
mc.current_server = mc.current_server->next;
1557
mc->current_server = mc->current_server->next;
1365
1558
block_time = 0; /* Call avahi to find new Mandos
1366
1559
servers, but don't block */
1367
1560
}
1369
1562
ret = avahi_simple_poll_iterate(s, (int)block_time);
1370
1563
}
1371
1564
if(ret != 0){
1372
if (ret > 0 or errno != EINTR){
1565
if(ret > 0 or errno != EINTR){
1373
1566
return (ret != 1) ? ret : 0;
1374
1567
}
1375
1568
}
1376
1569
}
1377
1570
}
1378
1571
1379
bool run_network_hooks(const char *mode, const char *interface,
1572
/* Set effective uid to 0, return errno */
1573
__attribute__((warn_unused_result))
1574
error_t raise_privileges(void){
1575
error_t old_errno = errno;
1576
error_t ret_errno = 0;
1577
if(seteuid(0) == -1){
1578
ret_errno = errno;
1579
}
1580
errno = old_errno;
1581
return ret_errno;
1582
}
1583
1584
/* Set effective and real user ID to 0. Return errno. */
1585
__attribute__((warn_unused_result))
1586
error_t raise_privileges_permanently(void){
1587
error_t old_errno = errno;
1588
error_t ret_errno = raise_privileges();
1589
if(ret_errno != 0){
1590
errno = old_errno;
1591
return ret_errno;
1592
}
1593
if(setuid(0) == -1){
1594
ret_errno = errno;
1595
}
1596
errno = old_errno;
1597
return ret_errno;
1598
}
1599
1600
/* Set effective user ID to unprivileged saved user ID */
1601
__attribute__((warn_unused_result))
1602
error_t lower_privileges(void){
1603
error_t old_errno = errno;
1604
error_t ret_errno = 0;
1605
if(seteuid(uid) == -1){
1606
ret_errno = errno;
1607
}
1608
errno = old_errno;
1609
return ret_errno;
1610
}
1611
1612
/* Lower privileges permanently */
1613
__attribute__((warn_unused_result))
1614
error_t lower_privileges_permanently(void){
1615
error_t old_errno = errno;
1616
error_t ret_errno = 0;
1617
if(setuid(uid) == -1){
1618
ret_errno = errno;
1619
}
1620
errno = old_errno;
1621
return ret_errno;
1622
}
1623
1624
__attribute__((nonnull))
1625
void run_network_hooks(const char *mode, const char *interface,
1380
1626
const float delay){
1381
struct dirent **direntries;
1382
struct dirent *direntry;
1383
int ret;
1384
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1385
alphasort);
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__ */
1386
1654
if(numhooks == -1){
1387
1655
perror_plus("scandir");
1388
} else {
1389
int devnull = open("/dev/null", O_RDONLY);
1390
for(int i = 0; i < numhooks; i++){
1391
direntry = direntries[0];
1392
char *fullname = NULL;
1393
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1394
if(ret < 0){
1656
return;
1657
}
1658
struct dirent *direntry;
1659
int ret;
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);
1666
}
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){
1395
1728
perror_plus("asprintf");
1396
continue;
1729
_exit(EX_OSERR);
1397
1730
}
1398
pid_t hook_pid = fork();
1399
if(hook_pid == 0){
1400
/* Child */
1401
dup2(devnull, STDIN_FILENO);
1402
close(devnull);
1403
dup2(STDERR_FILENO, STDOUT_FILENO);
1404
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1405
if(ret == -1){
1406
perror_plus("setenv");
1407
return false;
1408
}
1409
ret = setenv("DEVICE", interface, 1);
1410
if(ret == -1){
1411
perror_plus("setenv");
1412
return false;
1413
}
1414
ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1415
if(ret == -1){
1416
perror_plus("setenv");
1417
return false;
1418
}
1419
ret = setenv("MODE", mode, 1);
1420
if(ret == -1){
1421
perror_plus("setenv");
1422
return false;
1423
}
1424
char *delaystring;
1425
ret = asprintf(&delaystring, "%f", delay);
1426
if(ret == -1){
1427
perror_plus("asprintf");
1428
return false;
1429
}
1430
ret = setenv("DELAY", delaystring, 1);
1431
if(ret == -1){
1432
free(delaystring);
1433
perror_plus("setenv");
1434
return false;
1435
}
1731
ret = setenv("DELAY", delaystring, 1);
1732
if(ret == -1){
1436
1733
free(delaystring);
1437
ret = execl(fullname, direntry->d_name, mode, NULL);
1438
perror_plus("execl");
1439
} else {
1440
int status;
1441
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1442
perror_plus("waitpid");
1443
free(fullname);
1444
continue;
1445
}
1446
if(WIFEXITED(status)){
1447
if(WEXITSTATUS(status) != 0){
1448
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1449
" with status %d\n", direntry->d_name,
1450
WEXITSTATUS(status));
1451
free(fullname);
1452
continue;
1453
}
1454
} else if(WIFSIGNALED(status)){
1455
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1456
" signal %d\n", direntry->d_name,
1457
WTERMSIG(status));
1458
free(fullname);
1459
continue;
1460
} else {
1461
fprintf_plus(stderr, "Warning: network hook \"%s\""
1462
" crashed\n", direntry->d_name);
1463
free(fullname);
1464
continue;
1465
}
1466
}
1467
free(fullname);
1468
if(quit_now){
1469
break;
1470
}
1471
}
1472
close(devnull);
1473
}
1474
return true;
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;
1785
} else {
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);
1805
}
1806
1807
__attribute__((nonnull, warn_unused_result))
1808
error_t bring_up_interface(const char *const interface,
1809
const float delay){
1810
error_t old_errno = errno;
1811
int ret;
1812
struct ifreq network;
1813
unsigned int if_index = if_nametoindex(interface);
1814
if(if_index == 0){
1815
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1816
errno = old_errno;
1817
return ENXIO;
1818
}
1819
1820
if(quit_now){
1821
errno = old_errno;
1822
return EINTR;
1823
}
1824
1825
if(not interface_is_up(interface)){
1826
error_t ret_errno = 0, ioctl_errno = 0;
1827
if(not get_flags(interface, &network)){
1828
ret_errno = errno;
1829
fprintf_plus(stderr, "Failed to get flags for interface "
1830
"\"%s\"\n", interface);
1831
errno = old_errno;
1832
return ret_errno;
1833
}
1834
network.ifr_flags |= IFF_UP; /* set flag */
1835
1836
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1837
if(sd == -1){
1838
ret_errno = errno;
1839
perror_plus("socket");
1840
errno = old_errno;
1841
return ret_errno;
1842
}
1843
1844
if(quit_now){
1845
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1846
if(ret == -1){
1847
perror_plus("close");
1848
}
1849
errno = old_errno;
1850
return EINTR;
1851
}
1852
1853
if(debug){
1854
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1855
interface);
1856
}
1857
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
}
1864
1865
#ifdef __linux__
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
}
1877
}
1878
#endif /* __linux__ */
1879
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1880
ioctl_errno = errno;
1881
#ifdef __linux__
1882
if(restore_loglevel){
1883
ret_linux = klogctl(7, NULL, 0);
1884
if(ret_linux == -1){
1885
perror_plus("klogctl");
1886
}
1887
}
1888
#endif /* __linux__ */
1889
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
}
1899
1900
/* Close the socket */
1901
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1902
if(ret == -1){
1903
perror_plus("close");
1904
}
1905
1906
if(ret_setflags == -1){
1907
errno = ioctl_errno;
1908
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1909
errno = old_errno;
1910
return ioctl_errno;
1911
}
1912
} else if(debug){
1913
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1914
interface);
1915
}
1916
1917
/* Sleep checking until interface is running.
1918
Check every 0.25s, up to total time of delay */
1919
for(int i=0; i < delay * 4; i++){
1920
if(interface_is_running(interface)){
1921
break;
1922
}
1923
struct timespec sleeptime = { .tv_nsec = 250000000 };
1924
ret = nanosleep(&sleeptime, NULL);
1925
if(ret == -1 and errno != EINTR){
1926
perror_plus("nanosleep");
1927
}
1928
}
1929
1930
errno = old_errno;
1931
return 0;
1932
}
1933
1934
__attribute__((nonnull, warn_unused_result))
1935
error_t take_down_interface(const char *const interface){
1936
error_t old_errno = errno;
1937
struct ifreq network;
1938
unsigned int if_index = if_nametoindex(interface);
1939
if(if_index == 0){
1940
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1941
errno = old_errno;
1942
return ENXIO;
1943
}
1944
if(interface_is_up(interface)){
1945
error_t ret_errno = 0, ioctl_errno = 0;
1946
if(not get_flags(interface, &network) and debug){
1947
ret_errno = errno;
1948
fprintf_plus(stderr, "Failed to get flags for interface "
1949
"\"%s\"\n", interface);
1950
errno = old_errno;
1951
return ret_errno;
1952
}
1953
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1954
1955
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1956
if(sd == -1){
1957
ret_errno = errno;
1958
perror_plus("socket");
1959
errno = old_errno;
1960
return ret_errno;
1961
}
1962
1963
if(debug){
1964
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1965
interface);
1966
}
1967
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
}
1987
1988
/* Close the socket */
1989
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1990
if(ret == -1){
1991
perror_plus("close");
1992
}
1993
1994
if(ret_setflags == -1){
1995
errno = ioctl_errno;
1996
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1997
errno = old_errno;
1998
return ioctl_errno;
1999
}
2000
} else if(debug){
2001
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2002
interface);
2003
}
2004
2005
errno = old_errno;
2006
return 0;
1475
2007
}
1476
2008
1477
2009
int main(int argc, char *argv[]){
2010
mandos_context mc = { .server = NULL, .dh_bits = 0,
2011
.priority = "SECURE256:!CTYPE-X.509:"
2012
"+CTYPE-OPENPGP:!RSA", .current_server = NULL,
2013
.interfaces = NULL, .interfaces_size = 0 };
1478
2014
AvahiSServiceBrowser *sb = NULL;
1479
int error;
2015
error_t ret_errno;
1480
2016
int ret;
1481
2017
intmax_t tmpmax;
1482
2018
char *tmp;
1483
2019
int exitcode = EXIT_SUCCESS;
1484
const char *interface = "";
1485
struct ifreq network;
1486
int sd = -1;
1487
bool take_down_interface = false;
1488
uid_t uid;
1489
gid_t gid;
1490
char tempdir[] = "/tmp/mandosXXXXXX";
1491
bool tempdir_created = false;
2020
char *interfaces_to_take_down = NULL;
2021
size_t interfaces_to_take_down_size = 0;
2022
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2023
char old_tempdir[] = "/tmp/mandosXXXXXX";
2024
char *tempdir = NULL;
1492
2025
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1493
2026
const char *seckey = PATHDIR "/" SECKEY;
1494
2027
const char *pubkey = PATHDIR "/" PUBKEY;
2028
char *interfaces_hooks = NULL;
1495
2029
1496
2030
bool gnutls_initialized = false;
1497
2031
bool gpgme_initialized = false;
1559
2093
.group = 2 },
1560
2094
{ .name = "retry", .key = 132,
1561
2095
.arg = "SECONDS",
1562
.doc = "Retry interval used when denied by the mandos server",
2096
.doc = "Retry interval used when denied by the Mandos server",
1563
2097
.group = 2 },
1564
2098
{ .name = "network-hook-dir", .key = 133,
1565
2099
.arg = "DIR",
1588
2122
connect_to = arg;
1589
2123
break;
1590
2124
case 'i': /* --interface */
1591
interface = arg;
2125
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2126
arg, (int)',');
2127
if(ret_errno != 0){
2128
argp_error(state, "%s", strerror(ret_errno));
2129
}
1592
2130
break;
1593
2131
case 's': /* --seckey */
1594
2132
seckey = arg;
1637
2175
argp_state_help(state, state->out_stream,
1638
2176
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1639
2177
case 'V': /* --version */
1640
fprintf_plus(state->out_stream,
1641
"Mandos plugin mandos-client: ");
1642
2178
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1643
2179
exit(argp_err_exit_status);
1644
2180
break;
1672
2208
{
1673
2209
/* Work around Debian bug #633582:
1674
2210
<http://bugs.debian.org/633582> */
1675
struct stat st;
1676
1677
/* Re-raise priviliges */
1678
errno = 0;
1679
ret = seteuid(0);
1680
if(ret == -1){
1681
perror_plus("seteuid");
1682
}
1683
1684
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1685
int seckey_fd = open(seckey, O_RDONLY);
1686
if(seckey_fd == -1){
1687
perror_plus("open");
1688
} else {
1689
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1690
if(ret == -1){
1691
perror_plus("fstat");
1692
} else {
1693
if(S_ISREG(st.st_mode)
1694
and st.st_uid == 0 and st.st_gid == 0){
1695
ret = fchown(seckey_fd, uid, gid);
1696
if(ret == -1){
1697
perror_plus("fchown");
1698
}
1699
}
1700
}
1701
TEMP_FAILURE_RETRY(close(seckey_fd));
1702
}
1703
}
1704
1705
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1706
int pubkey_fd = open(pubkey, O_RDONLY);
1707
if(pubkey_fd == -1){
1708
perror_plus("open");
1709
} else {
1710
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1711
if(ret == -1){
1712
perror_plus("fstat");
1713
} else {
1714
if(S_ISREG(st.st_mode)
1715
and st.st_uid == 0 and st.st_gid == 0){
1716
ret = fchown(pubkey_fd, uid, gid);
1717
if(ret == -1){
1718
perror_plus("fchown");
1719
}
1720
}
1721
}
1722
TEMP_FAILURE_RETRY(close(pubkey_fd));
1723
}
1724
}
1725
1726
/* Lower privileges */
1727
errno = 0;
1728
ret = seteuid(uid);
1729
if(ret == -1){
1730
perror_plus("seteuid");
2211
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 {
2218
struct stat st;
2219
2220
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2221
int seckey_fd = open(seckey, O_RDONLY);
2222
if(seckey_fd == -1){
2223
perror_plus("open");
2224
} else {
2225
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2226
if(ret == -1){
2227
perror_plus("fstat");
2228
} else {
2229
if(S_ISREG(st.st_mode)
2230
and st.st_uid == 0 and st.st_gid == 0){
2231
ret = fchown(seckey_fd, uid, gid);
2232
if(ret == -1){
2233
perror_plus("fchown");
2234
}
2235
}
2236
}
2237
TEMP_FAILURE_RETRY(close(seckey_fd));
2238
}
2239
}
2240
2241
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2242
int pubkey_fd = open(pubkey, O_RDONLY);
2243
if(pubkey_fd == -1){
2244
perror_plus("open");
2245
} else {
2246
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2247
if(ret == -1){
2248
perror_plus("fstat");
2249
} else {
2250
if(S_ISREG(st.st_mode)
2251
and st.st_uid == 0 and st.st_gid == 0){
2252
ret = fchown(pubkey_fd, uid, gid);
2253
if(ret == -1){
2254
perror_plus("fchown");
2255
}
2256
}
2257
}
2258
TEMP_FAILURE_RETRY(close(pubkey_fd));
2259
}
2260
}
2261
2262
/* Lower privileges */
2263
ret_errno = lower_privileges();
2264
if(ret_errno != 0){
2265
errno = ret_errno;
2266
perror_plus("Failed to lower privileges");
2267
}
2268
}
2269
}
2270
2271
/* Remove invalid interface names (except "none") */
2272
{
2273
char *interface = NULL;
2274
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2275
interface))){
2276
if(strcmp(interface, "none") != 0
2277
and if_nametoindex(interface) == 0){
2278
if(interface[0] != '\0'){
2279
fprintf_plus(stderr, "Not using nonexisting interface"
2280
" \"%s\"\n", interface);
2281
}
2282
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2283
interface = NULL;
2284
}
1731
2285
}
1732
2286
}
1733
2287
1734
2288
/* Run network hooks */
1735
2289
{
1736
/* Re-raise priviliges */
1737
errno = 0;
1738
ret = seteuid(0);
1739
if(ret == -1){
1740
perror_plus("seteuid");
1741
}
1742
if(not run_network_hooks("start", interface, delay)){
1743
goto end;
1744
}
1745
/* Lower privileges */
1746
errno = 0;
1747
ret = seteuid(uid);
1748
if(ret == -1){
1749
perror_plus("seteuid");
1750
}
2290
if(mc.interfaces != NULL){
2291
interfaces_hooks = malloc(mc.interfaces_size);
2292
if(interfaces_hooks == NULL){
2293
perror_plus("malloc");
2294
goto end;
2295
}
2296
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2297
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2298
}
2299
run_network_hooks("start", interfaces_hooks != NULL ?
2300
interfaces_hooks : "", delay);
1751
2301
}
1752
2302
1753
2303
if(not debug){
1754
2304
avahi_set_log_function(empty_log);
1755
2305
}
1756
2306
1757
if(interface[0] == '\0'){
1758
struct dirent **direntries;
1759
/* First look for interfaces that are up */
1760
ret = scandir(sys_class_net, &direntries, up_interface,
1761
alphasort);
1762
if(ret == 0){
1763
/* No up interfaces, look for any good interfaces */
1764
free(direntries);
1765
ret = scandir(sys_class_net, &direntries, good_interface,
1766
alphasort);
1767
}
1768
if(ret >= 1){
1769
/* Pick the first interface returned */
1770
interface = strdup(direntries[0]->d_name);
1771
if(debug){
1772
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1773
}
1774
if(interface == NULL){
1775
perror_plus("malloc");
1776
free(direntries);
1777
exitcode = EXIT_FAILURE;
1778
goto end;
1779
}
1780
free(direntries);
1781
} else {
1782
free(direntries);
1783
fprintf_plus(stderr, "Could not find a network interface\n");
1784
exitcode = EXIT_FAILURE;
1785
goto end;
1786
}
1787
}
1788
1789
2307
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1790
2308
from the signal handler */
1791
2309
/* Initialize the pseudo-RNG for Avahi */
1792
2310
srand((unsigned int) time(NULL));
1793
mc.simple_poll = avahi_simple_poll_new();
1794
if(mc.simple_poll == NULL){
2311
simple_poll = avahi_simple_poll_new();
2312
if(simple_poll == NULL){
1795
2313
fprintf_plus(stderr,
1796
2314
"Avahi: Failed to create simple poll object.\n");
1797
2315
exitcode = EX_UNAVAILABLE;
1861
2379
}
1862
2380
}
1863
2381
1864
/* If the interface is down, bring it up */
1865
if(strcmp(interface, "none") != 0){
1866
if_index = (AvahiIfIndex) if_nametoindex(interface);
1867
if(if_index == 0){
1868
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1869
exitcode = EX_UNAVAILABLE;
1870
goto end;
1871
}
1872
1873
if(quit_now){
1874
goto end;
1875
}
1876
1877
/* Re-raise priviliges */
1878
errno = 0;
1879
ret = seteuid(0);
1880
if(ret == -1){
1881
perror_plus("seteuid");
1882
}
1883
1884
#ifdef __linux__
1885
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1886
messages about the network interface to mess up the prompt */
1887
ret = klogctl(8, NULL, 5);
1888
bool restore_loglevel = true;
1889
if(ret == -1){
1890
restore_loglevel = false;
1891
perror_plus("klogctl");
1892
}
1893
#endif /* __linux__ */
1894
1895
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1896
if(sd < 0){
1897
perror_plus("socket");
1898
exitcode = EX_OSERR;
1899
#ifdef __linux__
1900
if(restore_loglevel){
1901
ret = klogctl(7, NULL, 0);
1902
if(ret == -1){
1903
perror_plus("klogctl");
1904
}
1905
}
1906
#endif /* __linux__ */
1907
/* Lower privileges */
1908
errno = 0;
1909
ret = seteuid(uid);
1910
if(ret == -1){
1911
perror_plus("seteuid");
1912
}
1913
goto end;
1914
}
1915
strcpy(network.ifr_name, interface);
1916
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1917
if(ret == -1){
1918
perror_plus("ioctl SIOCGIFFLAGS");
1919
#ifdef __linux__
1920
if(restore_loglevel){
1921
ret = klogctl(7, NULL, 0);
1922
if(ret == -1){
1923
perror_plus("klogctl");
1924
}
1925
}
1926
#endif /* __linux__ */
1927
exitcode = EX_OSERR;
1928
/* Lower privileges */
1929
errno = 0;
1930
ret = seteuid(uid);
1931
if(ret == -1){
1932
perror_plus("seteuid");
1933
}
1934
goto end;
1935
}
1936
if((network.ifr_flags & IFF_UP) == 0){
1937
network.ifr_flags |= IFF_UP;
1938
take_down_interface = true;
1939
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1940
if(ret == -1){
1941
take_down_interface = false;
1942
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1943
exitcode = EX_OSERR;
1944
#ifdef __linux__
1945
if(restore_loglevel){
1946
ret = klogctl(7, NULL, 0);
1947
if(ret == -1){
1948
perror_plus("klogctl");
2382
/* If no interfaces were specified, make a list */
2383
if(mc.interfaces == NULL){
2384
struct dirent **direntries = NULL;
2385
/* Look for any good interfaces */
2386
ret = scandir(sys_class_net, &direntries, good_interface,
2387
alphasort);
2388
if(ret >= 1){
2389
/* Add all found interfaces to interfaces list */
2390
for(int i = 0; i < ret; ++i){
2391
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2392
direntries[i]->d_name);
2393
if(ret_errno != 0){
2394
errno = ret_errno;
2395
perror_plus("argz_add");
2396
free(direntries[i]);
2397
continue;
2398
}
2399
if(debug){
2400
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2401
direntries[i]->d_name);
2402
}
2403
free(direntries[i]);
2404
}
2405
free(direntries);
2406
} else {
2407
if(ret == 0){
2408
free(direntries);
2409
}
2410
fprintf_plus(stderr, "Could not find a network interface\n");
2411
exitcode = EXIT_FAILURE;
2412
goto end;
2413
}
2414
}
2415
2416
/* Bring up interfaces which are down, and remove any "none"s */
2417
{
2418
char *interface = NULL;
2419
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2420
interface))){
2421
/* If interface name is "none", stop bringing up interfaces.
2422
Also remove all instances of "none" from the list */
2423
if(strcmp(interface, "none") == 0){
2424
argz_delete(&mc.interfaces, &mc.interfaces_size,
2425
interface);
2426
interface = NULL;
2427
while((interface = argz_next(mc.interfaces,
2428
mc.interfaces_size, interface))){
2429
if(strcmp(interface, "none") == 0){
2430
argz_delete(&mc.interfaces, &mc.interfaces_size,
2431
interface);
2432
interface = NULL;
1949
2433
}
1950
2434
}
1951
#endif /* __linux__ */
1952
/* Lower privileges */
1953
errno = 0;
1954
ret = seteuid(uid);
1955
if(ret == -1){
1956
perror_plus("seteuid");
1957
}
1958
goto end;
1959
}
1960
}
1961
/* Sleep checking until interface is running.
1962
Check every 0.25s, up to total time of delay */
1963
for(int i=0; i < delay * 4; i++){
1964
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1965
if(ret == -1){
1966
perror_plus("ioctl SIOCGIFFLAGS");
1967
} else if(network.ifr_flags & IFF_RUNNING){
1968
2435
break;
1969
2436
}
1970
struct timespec sleeptime = { .tv_nsec = 250000000 };
1971
ret = nanosleep(&sleeptime, NULL);
1972
if(ret == -1 and errno != EINTR){
1973
perror_plus("nanosleep");
1974
}
1975
}
1976
if(not take_down_interface){
1977
/* We won't need the socket anymore */
1978
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1979
if(ret == -1){
1980
perror_plus("close");
1981
}
1982
}
1983
#ifdef __linux__
1984
if(restore_loglevel){
1985
/* Restores kernel loglevel to default */
1986
ret = klogctl(7, NULL, 0);
1987
if(ret == -1){
1988
perror_plus("klogctl");
1989
}
1990
}
1991
#endif /* __linux__ */
1992
/* Lower privileges */
1993
errno = 0;
1994
/* Lower privileges */
1995
ret = seteuid(uid);
1996
if(ret == -1){
1997
perror_plus("seteuid");
1998
}
2437
bool interface_was_up = interface_is_up(interface);
2438
errno = bring_up_interface(interface, delay);
2439
if(not interface_was_up){
2440
if(errno != 0){
2441
perror_plus("Failed to bring up interface");
2442
} else {
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
}
2449
}
2450
}
2451
}
2452
if(debug and (interfaces_to_take_down == NULL)){
2453
fprintf_plus(stderr, "No interfaces were brought up\n");
2454
}
2455
}
2456
2457
/* If we only got one interface, explicitly use only that one */
2458
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2459
if(debug){
2460
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2461
mc.interfaces);
2462
}
2463
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
1999
2464
}
2000
2465
2001
2466
if(quit_now){
2002
2467
goto end;
2003
2468
}
2004
2469
2005
ret = init_gnutls_global(pubkey, seckey);
2470
ret = init_gnutls_global(pubkey, seckey, &mc);
2006
2471
if(ret == -1){
2007
2472
fprintf_plus(stderr, "init_gnutls_global failed\n");
2008
2473
exitcode = EX_UNAVAILABLE;
2015
2480
goto end;
2016
2481
}
2017
2482
2018
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){
2019
2493
perror_plus("mkdtemp");
2020
2494
goto end;
2021
2495
}
2022
tempdir_created = true;
2023
2496
2024
2497
if(quit_now){
2025
2498
goto end;
2026
2499
}
2027
2500
2028
if(not init_gpgme(pubkey, seckey, tempdir)){
2501
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2029
2502
fprintf_plus(stderr, "init_gpgme failed\n");
2030
2503
exitcode = EX_UNAVAILABLE;
2031
2504
goto end;
2041
2514
/* Connect directly, do not use Zeroconf */
2042
2515
/* (Mainly meant for debugging) */
2043
2516
char *address = strrchr(connect_to, ':');
2517
2044
2518
if(address == NULL){
2045
2519
fprintf_plus(stderr, "No colon in address\n");
2046
2520
exitcode = EX_USAGE;
2051
2525
goto end;
2052
2526
}
2053
2527
2054
uint16_t port;
2528
in_port_t port;
2055
2529
errno = 0;
2056
2530
tmpmax = strtoimax(address+1, &tmp, 10);
2057
2531
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2058
or tmpmax != (uint16_t)tmpmax){
2532
or tmpmax != (in_port_t)tmpmax){
2059
2533
fprintf_plus(stderr, "Bad port number\n");
2060
2534
exitcode = EX_USAGE;
2061
2535
goto end;
2062
2536
}
2063
2537
2064
2538
if(quit_now){
2065
2539
goto end;
2066
2540
}
2067
2541
2068
port = (uint16_t)tmpmax;
2542
port = (in_port_t)tmpmax;
2069
2543
*address = '\0';
2070
2544
/* Colon in address indicates IPv6 */
2071
2545
int af;
2087
2561
}
2088
2562
2089
2563
while(not quit_now){
2090
ret = start_mandos_communication(address, port, if_index, af);
2564
ret = start_mandos_communication(address, port, if_index, af,
2565
&mc);
2091
2566
if(quit_now or ret == 0){
2092
2567
break;
2093
2568
}
2095
2570
fprintf_plus(stderr, "Retrying in %d seconds\n",
2096
2571
(int)retry_interval);
2097
2572
}
2098
sleep((int)retry_interval);
2573
sleep((unsigned int)retry_interval);
2099
2574
}
2100
2575
2101
if (not quit_now){
2576
if(not quit_now){
2102
2577
exitcode = EXIT_SUCCESS;
2103
2578
}
2104
2579
2119
2594
config.publish_domain = 0;
2120
2595
2121
2596
/* Allocate a new server */
2122
mc.server = avahi_server_new(avahi_simple_poll_get
2123
(mc.simple_poll), &config, NULL,
2124
NULL, &error);
2597
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2598
&config, NULL, NULL, &ret_errno);
2125
2599
2126
2600
/* Free the Avahi configuration data */
2127
2601
avahi_server_config_free(&config);
2130
2604
/* Check if creating the Avahi server object succeeded */
2131
2605
if(mc.server == NULL){
2132
2606
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2133
avahi_strerror(error));
2607
avahi_strerror(ret_errno));
2134
2608
exitcode = EX_UNAVAILABLE;
2135
2609
goto end;
2136
2610
}
2142
2616
/* Create the Avahi service browser */
2143
2617
sb = avahi_s_service_browser_new(mc.server, if_index,
2144
2618
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2145
NULL, 0, browse_callback, NULL);
2619
NULL, 0, browse_callback,
2620
(void *)&mc);
2146
2621
if(sb == NULL){
2147
2622
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2148
2623
avahi_strerror(avahi_server_errno(mc.server)));
2159
2634
if(debug){
2160
2635
fprintf_plus(stderr, "Starting Avahi loop search\n");
2161
2636
}
2162
2163
ret = avahi_loop_with_timeout(mc.simple_poll,
2164
(int)(retry_interval * 1000));
2637
2638
ret = avahi_loop_with_timeout(simple_poll,
2639
(int)(retry_interval * 1000), &mc);
2165
2640
if(debug){
2166
2641
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2167
2642
(ret == 0) ? "successfully" : "with error");
2174
2649
}
2175
2650
2176
2651
/* Cleanup things */
2652
free(mc.interfaces);
2653
2177
2654
if(sb != NULL)
2178
2655
avahi_s_service_browser_free(sb);
2179
2656
2180
2657
if(mc.server != NULL)
2181
2658
avahi_server_free(mc.server);
2182
2659
2183
if(mc.simple_poll != NULL)
2184
avahi_simple_poll_free(mc.simple_poll);
2660
if(simple_poll != NULL)
2661
avahi_simple_poll_free(simple_poll);
2185
2662
2186
2663
if(gnutls_initialized){
2187
2664
gnutls_certificate_free_credentials(mc.cred);
2192
2669
if(gpgme_initialized){
2193
2670
gpgme_release(mc.ctx);
2194
2671
}
2195
2672
2196
2673
/* Cleans up the circular linked list of Mandos servers the client
2197
2674
has seen */
2198
2675
if(mc.current_server != NULL){
2199
2676
mc.current_server->prev->next = NULL;
2200
2677
while(mc.current_server != NULL){
2201
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
2202
2687
free(mc.current_server);
2203
2688
mc.current_server = next;
2204
2689
}
2205
2690
}
2206
2691
2207
/* Re-raise priviliges */
2692
/* Re-raise privileges */
2208
2693
{
2209
errno = 0;
2210
ret = seteuid(0);
2211
if(ret == -1){
2212
perror_plus("seteuid");
2213
}
2214
/* Run network hooks */
2215
if(not run_network_hooks("stop", interface, delay)){
2216
goto end;
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
}
2217
2721
}
2218
2722
2219
/* Take down the network interface */
2220
if(take_down_interface and geteuid() == 0){
2221
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2222
if(ret == -1){
2223
perror_plus("ioctl SIOCGIFFLAGS");
2224
} else if(network.ifr_flags & IFF_UP){
2225
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2226
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2227
if(ret == -1){
2228
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2229
}
2230
}
2231
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2232
if(ret == -1){
2233
perror_plus("close");
2234
}
2723
ret_errno = lower_privileges_permanently();
2724
if(ret_errno != 0){
2725
errno = ret_errno;
2726
perror_plus("Failed to lower privileges permanently");
2235
2727
}
2236
2728
}
2237
/* Lower privileges permanently */
2238
errno = 0;
2239
ret = setuid(uid);
2240
if(ret == -1){
2241
perror_plus("setuid");
2242
}
2729
2730
free(interfaces_to_take_down);
2731
free(interfaces_hooks);
2243
2732
2244
2733
/* Removes the GPGME temp directory and all files inside */
2245
if(tempdir_created){
2734
if(tempdir != NULL){
2246
2735
struct dirent **direntries = NULL;
2247
struct dirent *direntry = NULL;
2248
int numentries = scandir(tempdir, &direntries, notdotentries,
2249
alphasort);
2250
if (numentries > 0){
2251
for(int i = 0; i < numentries; i++){
2252
direntry = direntries[i];
2253
char *fullname = NULL;
2254
ret = asprintf(&fullname, "%s/%s", tempdir,
2255
direntry->d_name);
2256
if(ret < 0){
2257
perror_plus("asprintf");
2258
continue;
2259
}
2260
ret = remove(fullname);
2261
if(ret == -1){
2262
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2263
strerror(errno));
2264
}
2265
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
}
2266
2773
}
2267
}
2268
2269
/* need to clean even if 0 because man page doesn't specify */
2270
free(direntries);
2271
if (numentries == -1){
2272
perror_plus("scandir");
2273
}
2274
ret = rmdir(tempdir);
2275
if(ret == -1 and errno != ENOENT){
2276
perror_plus("rmdir");
2774
TEMP_FAILURE_RETRY(close(tempdir_fd));
2277
2775
}
2278
2776
}
2279
2777
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0