46
111
#include <avahi-common/malloc.h>
47
112
#include <avahi-common/error.h>
50
#include <sys/types.h> /* socket(), inet_pton() */
51
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
52
struct in6_addr, inet_pton() */
53
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
54
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
56
#include <unistd.h> /* close() */
57
#include <netinet/in.h>
58
#include <stdbool.h> /* true */
59
#include <string.h> /* memset */
60
#include <arpa/inet.h> /* inet_pton() */
61
#include <iso646.h> /* not */
64
#include <errno.h> /* perror() */
71
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
73
#define CERTFILE CERT_ROOT "openpgp-client.txt"
74
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
115
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
118
init_gnutls_session(),
120
#include <gnutls/openpgp.h>
121
/* gnutls_certificate_set_openpgp_key_file(),
122
GNUTLS_OPENPGP_FMT_BASE64 */
125
#include <gpgme.h> /* All GPGME types, constants and
128
GPGME_PROTOCOL_OpenPGP,
75
131
#define BUFFER_SIZE 256
133
#define PATHDIR "/conf/conf.d/mandos"
134
#define SECKEY "seckey.txt"
135
#define PUBKEY "pubkey.txt"
136
#define HOOKDIR "/lib/mandos/network-hooks.d"
78
138
bool debug = false;
139
static const char mandos_protocol_version[] = "1";
140
const char *argp_program_version = "mandos-client " VERSION;
141
const char *argp_program_bug_address = "<mandos@recompile.se>";
142
static const char sys_class_net[] = "/sys/class/net";
143
char *connect_to = NULL;
144
const char *hookdir = HOOKDIR;
149
/* Doubly linked list that need to be circularly linked when used */
150
typedef struct server{
153
AvahiIfIndex if_index;
155
struct timespec last_seen;
160
/* Used for passing in values through the Avahi callback functions */
81
gnutls_session_t session;
82
163
gnutls_certificate_credentials_t cred;
164
unsigned int dh_bits;
83
165
gnutls_dh_params_t dh_params;
87
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet, const char *homedir){
89
gpgme_data_t dh_crypto, dh_plain;
166
const char *priority;
168
server *current_server;
170
size_t interfaces_size;
173
/* global so signal handler can reach it*/
174
AvahiSimplePoll *simple_poll;
176
sig_atomic_t quit_now = 0;
177
int signal_received = 0;
179
/* Function to use when printing errors */
180
void perror_plus(const char *print_text){
182
fprintf(stderr, "Mandos plugin %s: ",
183
program_invocation_short_name);
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
189
int fprintf_plus(FILE *stream, const char *format, ...){
191
va_start (ap, format);
193
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
194
program_invocation_short_name));
195
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
199
* Make additional room in "buffer" for at least BUFFER_SIZE more
200
* bytes. "buffer_capacity" is how much is currently allocated,
201
* "buffer_length" is how much is already used.
203
__attribute__((nonnull, warn_unused_result))
204
size_t incbuffer(char **buffer, size_t buffer_length,
205
size_t buffer_capacity){
206
if(buffer_length + BUFFER_SIZE > buffer_capacity){
207
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
209
int old_errno = errno;
216
buffer_capacity += BUFFER_SIZE;
218
return buffer_capacity;
221
/* Add server to set of servers to retry periodically */
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){
226
server *new_server = malloc(sizeof(server));
227
if(new_server == NULL){
228
perror_plus("malloc");
231
*new_server = (server){ .ip = strdup(ip),
233
.if_index = if_index,
235
if(new_server->ip == NULL){
236
perror_plus("strdup");
239
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
241
perror_plus("clock_gettime");
244
/* Special case of first server */
245
if(*current_server == NULL){
246
new_server->next = new_server;
247
new_server->prev = new_server;
248
*current_server = new_server;
250
/* Place the new server last in the list */
251
new_server->next = *current_server;
252
new_server->prev = (*current_server)->prev;
253
new_server->prev->next = new_server;
254
(*current_server)->prev = new_server;
262
__attribute__((nonnull, warn_unused_result))
263
static bool init_gpgme(const char * const seckey,
264
const char * const pubkey,
265
const char * const tempdir,
93
ssize_t new_packet_capacity = 0;
94
ssize_t new_packet_length = 0;
95
268
gpgme_engine_info_t engine_info;
98
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
271
* Helper function to insert pub and seckey to the engine keyring.
273
bool import_key(const char * const filename){
276
gpgme_data_t pgp_data;
278
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
284
rc = gpgme_data_new_from_fd(&pgp_data, fd);
285
if(rc != GPG_ERR_NO_ERROR){
286
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
287
gpgme_strsource(rc), gpgme_strerror(rc));
291
rc = gpgme_op_import(mc->ctx, pgp_data);
292
if(rc != GPG_ERR_NO_ERROR){
293
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
294
gpgme_strsource(rc), gpgme_strerror(rc));
298
ret = (int)TEMP_FAILURE_RETRY(close(fd));
300
perror_plus("close");
302
gpgme_data_release(pgp_data);
307
fprintf_plus(stderr, "Initializing GPGME\n");
102
311
gpgme_check_version(NULL);
103
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
312
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
313
if(rc != GPG_ERR_NO_ERROR){
314
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
315
gpgme_strsource(rc), gpgme_strerror(rc));
105
/* Set GPGME home directory */
106
rc = gpgme_get_engine_info (&engine_info);
107
if (rc != GPG_ERR_NO_ERROR){
108
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
109
gpgme_strsource(rc), gpgme_strerror(rc));
319
/* Set GPGME home directory for the OpenPGP engine only */
320
rc = gpgme_get_engine_info(&engine_info);
321
if(rc != GPG_ERR_NO_ERROR){
322
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
323
gpgme_strsource(rc), gpgme_strerror(rc));
112
326
while(engine_info != NULL){
113
327
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
114
328
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
115
engine_info->file_name, homedir);
329
engine_info->file_name, tempdir);
118
332
engine_info = engine_info->next;
120
334
if(engine_info == NULL){
121
fprintf(stderr, "Could not set home dir to %s\n", homedir);
125
/* Create new GPGME data buffer from packet buffer */
126
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
127
if (rc != GPG_ERR_NO_ERROR){
128
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
129
gpgme_strsource(rc), gpgme_strerror(rc));
335
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
340
/* Create new GPGME "context" */
341
rc = gpgme_new(&(mc->ctx));
342
if(rc != GPG_ERR_NO_ERROR){
343
fprintf_plus(stderr, "Mandos plugin mandos-client: "
344
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
349
if(not import_key(pubkey) or not import_key(seckey)){
357
* Decrypt OpenPGP data.
358
* Returns -1 on error
360
__attribute__((nonnull, warn_unused_result))
361
static ssize_t pgp_packet_decrypt(const char *cryptotext,
365
gpgme_data_t dh_crypto, dh_plain;
368
size_t plaintext_capacity = 0;
369
ssize_t plaintext_length = 0;
372
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
375
/* Create new GPGME data buffer from memory cryptotext */
376
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
378
if(rc != GPG_ERR_NO_ERROR){
379
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
380
gpgme_strsource(rc), gpgme_strerror(rc));
133
384
/* Create new empty GPGME data buffer for the plaintext */
134
385
rc = gpgme_data_new(&dh_plain);
135
if (rc != GPG_ERR_NO_ERROR){
136
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
137
gpgme_strsource(rc), gpgme_strerror(rc));
141
/* Create new GPGME "context" */
142
rc = gpgme_new(&ctx);
143
if (rc != GPG_ERR_NO_ERROR){
144
fprintf(stderr, "bad gpgme_new: %s: %s\n",
145
gpgme_strsource(rc), gpgme_strerror(rc));
149
/* Decrypt data from the FILE pointer to the plaintext data
151
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
152
if (rc != GPG_ERR_NO_ERROR){
153
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
154
gpgme_strsource(rc), gpgme_strerror(rc));
159
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
163
gpgme_decrypt_result_t result;
164
result = gpgme_op_decrypt_result(ctx);
166
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
168
fprintf(stderr, "Unsupported algorithm: %s\n",
169
result->unsupported_algorithm);
170
fprintf(stderr, "Wrong key usage: %d\n",
171
result->wrong_key_usage);
172
if(result->file_name != NULL){
173
fprintf(stderr, "File name: %s\n", result->file_name);
175
gpgme_recipient_t recipient;
176
recipient = result->recipients;
386
if(rc != GPG_ERR_NO_ERROR){
387
fprintf_plus(stderr, "Mandos plugin mandos-client: "
388
"bad gpgme_data_new: %s: %s\n",
389
gpgme_strsource(rc), gpgme_strerror(rc));
390
gpgme_data_release(dh_crypto);
394
/* Decrypt data from the cryptotext data buffer to the plaintext
396
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
397
if(rc != GPG_ERR_NO_ERROR){
398
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
399
gpgme_strsource(rc), gpgme_strerror(rc));
400
plaintext_length = -1;
402
gpgme_decrypt_result_t result;
403
result = gpgme_op_decrypt_result(mc->ctx);
405
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
407
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
408
result->unsupported_algorithm);
409
fprintf_plus(stderr, "Wrong key usage: %u\n",
410
result->wrong_key_usage);
411
if(result->file_name != NULL){
412
fprintf_plus(stderr, "File name: %s\n", result->file_name);
414
gpgme_recipient_t recipient;
415
recipient = result->recipients;
178
416
while(recipient != NULL){
179
fprintf(stderr, "Public key algorithm: %s\n",
180
gpgme_pubkey_algo_name(recipient->pubkey_algo));
181
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
182
fprintf(stderr, "Secret key available: %s\n",
183
recipient->status == GPG_ERR_NO_SECKEY
417
fprintf_plus(stderr, "Public key algorithm: %s\n",
418
gpgme_pubkey_algo_name
419
(recipient->pubkey_algo));
420
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
421
fprintf_plus(stderr, "Secret key available: %s\n",
422
recipient->status == GPG_ERR_NO_SECKEY
185
424
recipient = recipient->next;
191
/* Delete the GPGME FILE pointer cryptotext data buffer */
192
gpgme_data_release(dh_crypto);
432
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
194
435
/* Seek back to the beginning of the GPGME plaintext data buffer */
195
gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
436
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
437
perror_plus("gpgme_data_seek");
438
plaintext_length = -1;
199
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
200
*new_packet = realloc(*new_packet,
201
(unsigned int)new_packet_capacity
203
if (*new_packet == NULL){
207
new_packet_capacity += BUFFER_SIZE;
444
plaintext_capacity = incbuffer(plaintext,
445
(size_t)plaintext_length,
447
if(plaintext_capacity == 0){
448
perror_plus("incbuffer");
449
plaintext_length = -1;
210
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
453
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
212
455
/* Print the data, if any */
217
perror("gpgme_data_read");
220
new_packet_length += ret;
223
/* FIXME: check characters before printing to screen so to not print
224
terminal control characters */
226
/* fprintf(stderr, "decrypted password is: "); */
227
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
228
/* fprintf(stderr, "\n"); */
461
perror_plus("gpgme_data_read");
462
plaintext_length = -1;
465
plaintext_length += ret;
469
fprintf_plus(stderr, "Decrypted password is: ");
470
for(ssize_t i = 0; i < plaintext_length; i++){
471
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
473
fprintf(stderr, "\n");
478
/* Delete the GPGME cryptotext data buffer */
479
gpgme_data_release(dh_crypto);
231
481
/* Delete the GPGME plaintext data buffer */
232
482
gpgme_data_release(dh_plain);
233
return new_packet_length;
483
return plaintext_length;
236
static const char * safer_gnutls_strerror (int value) {
237
const char *ret = gnutls_strerror (value);
486
__attribute__((warn_unused_result))
487
static const char *safer_gnutls_strerror(int value){
488
const char *ret = gnutls_strerror(value);
239
490
ret = "(unknown)";
243
void debuggnutls(__attribute__((unused)) int level,
245
fprintf(stderr, "%s", string);
494
/* GnuTLS log function callback */
495
__attribute__((nonnull))
496
static void debuggnutls(__attribute__((unused)) int level,
498
fprintf_plus(stderr, "GnuTLS: %s", string);
248
int initgnutls(encrypted_session *es){
501
__attribute__((nonnull, warn_unused_result))
502
static int init_gnutls_global(const char *pubkeyfilename,
503
const char *seckeyfilename,
253
fprintf(stderr, "Initializing GnuTLS\n");
508
fprintf_plus(stderr, "Initializing GnuTLS\n");
256
if ((ret = gnutls_global_init ())
257
!= GNUTLS_E_SUCCESS) {
258
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
511
ret = gnutls_global_init();
512
if(ret != GNUTLS_E_SUCCESS){
513
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
514
safer_gnutls_strerror(ret));
519
/* "Use a log level over 10 to enable all debugging options."
263
522
gnutls_global_set_log_level(11);
264
523
gnutls_global_set_log_function(debuggnutls);
267
/* openpgp credentials */
268
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
269
!= GNUTLS_E_SUCCESS) {
270
fprintf (stderr, "memory error: %s\n",
271
safer_gnutls_strerror(ret));
526
/* OpenPGP credentials */
527
ret = gnutls_certificate_allocate_credentials(&mc->cred);
528
if(ret != GNUTLS_E_SUCCESS){
529
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
530
safer_gnutls_strerror(ret));
531
gnutls_global_deinit();
276
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
277
" and keyfile %s as GnuTLS credentials\n", CERTFILE,
536
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
537
" secret key %s as GnuTLS credentials\n",
281
542
ret = gnutls_certificate_set_openpgp_key_file
282
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
283
if (ret != GNUTLS_E_SUCCESS) {
285
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
287
ret, CERTFILE, KEYFILE);
288
fprintf(stdout, "The Error is: %s\n",
289
safer_gnutls_strerror(ret));
293
//GnuTLS server initialization
294
if ((ret = gnutls_dh_params_init (&es->dh_params))
295
!= GNUTLS_E_SUCCESS) {
296
fprintf (stderr, "Error in dh parameter initialization: %s\n",
297
safer_gnutls_strerror(ret));
301
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
302
!= GNUTLS_E_SUCCESS) {
303
fprintf (stderr, "Error in prime generation: %s\n",
304
safer_gnutls_strerror(ret));
308
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
310
// GnuTLS session creation
311
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
312
!= GNUTLS_E_SUCCESS){
313
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
314
safer_gnutls_strerror(ret));
317
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
318
!= GNUTLS_E_SUCCESS) {
319
fprintf(stderr, "Syntax error at: %s\n", err);
320
fprintf(stderr, "GnuTLS error: %s\n",
321
safer_gnutls_strerror(ret));
325
if ((ret = gnutls_credentials_set
326
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
327
!= GNUTLS_E_SUCCESS) {
328
fprintf(stderr, "Error setting a credentials set: %s\n",
329
safer_gnutls_strerror(ret));
543
(mc->cred, pubkeyfilename, seckeyfilename,
544
GNUTLS_OPENPGP_FMT_BASE64);
545
if(ret != GNUTLS_E_SUCCESS){
547
"Error[%d] while reading the OpenPGP key pair ('%s',"
548
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
549
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
550
safer_gnutls_strerror(ret));
554
/* GnuTLS server initialization */
555
ret = gnutls_dh_params_init(&mc->dh_params);
556
if(ret != GNUTLS_E_SUCCESS){
557
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
558
" initialization: %s\n",
559
safer_gnutls_strerror(ret));
562
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
563
if(ret != GNUTLS_E_SUCCESS){
564
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
565
safer_gnutls_strerror(ret));
569
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
575
gnutls_certificate_free_credentials(mc->cred);
576
gnutls_global_deinit();
577
gnutls_dh_params_deinit(mc->dh_params);
581
__attribute__((nonnull, warn_unused_result))
582
static int init_gnutls_session(gnutls_session_t *session,
585
/* GnuTLS session creation */
587
ret = gnutls_init(session, GNUTLS_SERVER);
591
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
592
if(ret != GNUTLS_E_SUCCESS){
594
"Error in GnuTLS session initialization: %s\n",
595
safer_gnutls_strerror(ret));
601
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
603
gnutls_deinit(*session);
606
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
607
if(ret != GNUTLS_E_SUCCESS){
608
fprintf_plus(stderr, "Syntax error at: %s\n", err);
609
fprintf_plus(stderr, "GnuTLS error: %s\n",
610
safer_gnutls_strerror(ret));
611
gnutls_deinit(*session);
617
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
620
gnutls_deinit(*session);
623
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
624
if(ret != GNUTLS_E_SUCCESS){
625
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
626
safer_gnutls_strerror(ret));
627
gnutls_deinit(*session);
333
631
/* ignore client certificate if any. */
334
gnutls_certificate_server_set_request (es->session,
632
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
337
gnutls_dh_set_prime_bits (es->session, DH_BITS);
634
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
342
void empty_log(__attribute__((unused)) AvahiLogLevel level,
343
__attribute__((unused)) const char *txt){}
639
/* Avahi log function callback */
640
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
641
__attribute__((unused)) const char *txt){}
345
int start_mandos_communication(const char *ip, uint16_t port,
346
AvahiIfIndex if_index){
348
struct sockaddr_in6 to;
349
encrypted_session es;
643
/* Called when a Mandos server is found */
644
__attribute__((nonnull, warn_unused_result))
645
static int start_mandos_communication(const char *ip, in_port_t port,
646
AvahiIfIndex if_index,
647
int af, mandos_context *mc){
648
int ret, tcp_sd = -1;
650
struct sockaddr_storage to;
350
651
char *buffer = NULL;
351
char *decrypted_buffer;
652
char *decrypted_buffer = NULL;
352
653
size_t buffer_length = 0;
353
654
size_t buffer_capacity = 0;
354
ssize_t decrypted_buffer_size;
357
char interface[IF_NAMESIZE];
360
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
364
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
370
if(if_indextoname((unsigned int)if_index, interface) == NULL){
372
perror("if_indextoname");
378
fprintf(stderr, "Binding to interface %s\n", interface);
381
memset(&to,0,sizeof(to)); /* Spurious warning */
382
to.sin6_family = AF_INET6;
383
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
657
gnutls_session_t session;
658
int pf; /* Protocol family */
675
fprintf_plus(stderr, "Bad address family: %d\n", af);
680
/* If the interface is specified and we have a list of interfaces */
681
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
682
/* Check if the interface is one of the interfaces we are using */
685
char *interface = NULL;
686
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
688
if(if_nametoindex(interface) == (unsigned int)if_index){
695
/* This interface does not match any in the list, so we don't
696
connect to the server */
698
char interface[IF_NAMESIZE];
699
if(if_indextoname((unsigned int)if_index, interface) == NULL){
700
perror_plus("if_indextoname");
702
fprintf_plus(stderr, "Skipping server on non-used interface"
704
if_indextoname((unsigned int)if_index,
712
ret = init_gnutls_session(&session, mc);
718
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
719
PRIuMAX "\n", ip, (uintmax_t)port);
722
tcp_sd = socket(pf, SOCK_STREAM, 0);
725
perror_plus("socket");
735
memset(&to, 0, sizeof(to));
737
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
738
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
740
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
741
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
745
perror_plus("inet_pton");
389
fprintf(stderr, "Bad address: %s\n", ip);
392
to.sin6_port = htons(port); /* Spurious warning */
394
to.sin6_scope_id = (uint32_t)if_index;
397
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
398
/* char addrstr[INET6_ADDRSTRLEN]; */
399
/* if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr, */
400
/* sizeof(addrstr)) == NULL){ */
401
/* perror("inet_ntop"); */
403
/* fprintf(stderr, "Really connecting to: %s, port %d\n", */
404
/* addrstr, ntohs(to.sin6_port)); */
408
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
414
ret = initgnutls (&es);
420
gnutls_transport_set_ptr (es.session,
421
(gnutls_transport_ptr_t) tcp_sd);
424
fprintf(stderr, "Establishing TLS session with %s\n", ip);
427
ret = gnutls_handshake (es.session);
429
if (ret != GNUTLS_E_SUCCESS){
751
fprintf_plus(stderr, "Bad address: %s\n", ip);
756
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
757
if(IN6_IS_ADDR_LINKLOCAL
758
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
759
if(if_index == AVAHI_IF_UNSPEC){
760
fprintf_plus(stderr, "An IPv6 link-local address is"
761
" incomplete without a network interface\n");
765
/* Set the network interface number as scope */
766
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
769
((struct sockaddr_in *)&to)->sin_port = htons(port);
778
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
779
char interface[IF_NAMESIZE];
780
if(if_indextoname((unsigned int)if_index, interface) == NULL){
781
perror_plus("if_indextoname");
783
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
784
"\n", ip, interface, (uintmax_t)port);
787
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
788
ip, (uintmax_t)port);
790
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
791
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
793
ret = getnameinfo((struct sockaddr *)&to,
794
sizeof(struct sockaddr_in6),
795
addrstr, sizeof(addrstr), NULL, 0,
798
ret = getnameinfo((struct sockaddr *)&to,
799
sizeof(struct sockaddr_in),
800
addrstr, sizeof(addrstr), NULL, 0,
803
if(ret == EAI_SYSTEM){
804
perror_plus("getnameinfo");
805
} else if(ret != 0) {
806
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
807
} else if(strcmp(addrstr, ip) != 0){
808
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
818
ret = connect(tcp_sd, (struct sockaddr *)&to,
819
sizeof(struct sockaddr_in6));
821
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
822
sizeof(struct sockaddr_in));
825
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
827
perror_plus("connect");
838
const char *out = mandos_protocol_version;
841
size_t out_size = strlen(out);
842
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
843
out_size - written));
846
perror_plus("write");
850
written += (size_t)ret;
851
if(written < out_size){
854
if(out == mandos_protocol_version){
869
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
877
/* This casting via intptr_t is to eliminate warning about casting
878
an int to a pointer type. This is exactly how the GnuTLS Guile
879
function "set-session-transport-fd!" does it. */
880
gnutls_transport_set_ptr(session,
881
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
889
ret = gnutls_handshake(session);
894
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
896
if(ret != GNUTLS_E_SUCCESS){
431
fprintf(stderr, "\n*** Handshake failed ***\n");
898
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
438
//Retrieve OpenPGP packet that contains the wanted password
905
/* Read OpenPGP packet that contains the wanted password */
441
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
908
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
446
if (buffer_length + BUFFER_SIZE > buffer_capacity){
447
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
452
buffer_capacity += BUFFER_SIZE;
455
ret = gnutls_record_recv
456
(es.session, buffer+buffer_length, BUFFER_SIZE);
919
buffer_capacity = incbuffer(&buffer, buffer_length,
921
if(buffer_capacity == 0){
923
perror_plus("incbuffer");
933
sret = gnutls_record_recv(session, buffer+buffer_length,
462
940
case GNUTLS_E_INTERRUPTED:
463
941
case GNUTLS_E_AGAIN:
465
943
case GNUTLS_E_REHANDSHAKE:
466
ret = gnutls_handshake (es.session);
468
fprintf(stderr, "\n*** Handshake failed ***\n");
945
ret = gnutls_handshake(session);
951
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
953
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
475
fprintf(stderr, "Unknown error while reading data from"
476
" encrypted session with mandos server\n");
478
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
961
fprintf_plus(stderr, "Unknown error while reading data from"
962
" encrypted session with Mandos server\n");
963
gnutls_bye(session, GNUTLS_SHUT_RDWR);
482
buffer_length += (size_t) ret;
486
if (buffer_length > 0){
487
decrypted_buffer_size = pgp_packet_decrypt(buffer,
491
if (decrypted_buffer_size >= 0){
968
buffer_length += (size_t) sret;
973
fprintf_plus(stderr, "Closing TLS session\n");
982
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
987
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
989
if(buffer_length > 0){
990
ssize_t decrypted_buffer_size;
991
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
992
&decrypted_buffer, mc);
993
if(decrypted_buffer_size >= 0){
492
996
while(written < (size_t) decrypted_buffer_size){
493
ret = (int)fwrite (decrypted_buffer + written, 1,
494
(size_t)decrypted_buffer_size - written,
1002
ret = (int)fwrite(decrypted_buffer + written, 1,
1003
(size_t)decrypted_buffer_size - written,
496
1005
if(ret == 0 and ferror(stdout)){
498
fprintf(stderr, "Error writing encrypted data: %s\n",
1008
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
504
1014
written += (size_t)ret;
506
free(decrypted_buffer);
1020
/* Shutdown procedure */
1025
free(decrypted_buffer);
1028
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1034
perror_plus("close");
1036
gnutls_deinit(session);
515
fprintf(stderr, "Closing TLS session\n");
519
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
522
gnutls_deinit (es.session);
523
gnutls_certificate_free_credentials (es.cred);
524
gnutls_global_deinit ();
528
static AvahiSimplePoll *simple_poll = NULL;
529
static AvahiServer *server = NULL;
531
static void resolve_callback(
532
AvahiSServiceResolver *r,
533
AvahiIfIndex interface,
534
AVAHI_GCC_UNUSED AvahiProtocol protocol,
535
AvahiResolverEvent event,
539
const char *host_name,
540
const AvahiAddress *address,
542
AVAHI_GCC_UNUSED AvahiStringList *txt,
543
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
544
AVAHI_GCC_UNUSED void* userdata) {
546
assert(r); /* Spurious warning */
1046
__attribute__((nonnull))
1047
static void resolve_callback(AvahiSServiceResolver *r,
1048
AvahiIfIndex interface,
1049
AvahiProtocol proto,
1050
AvahiResolverEvent event,
1054
const char *host_name,
1055
const AvahiAddress *address,
1057
AVAHI_GCC_UNUSED AvahiStringList *txt,
1058
AVAHI_GCC_UNUSED AvahiLookupResultFlags
548
1065
/* Called whenever a service has been resolved successfully or
553
1074
case AVAHI_RESOLVER_FAILURE:
554
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
555
" type '%s' in domain '%s': %s\n", name, type, domain,
556
avahi_strerror(avahi_server_errno(server)));
1075
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1076
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1078
avahi_strerror(avahi_server_errno
1079
(((mandos_context*)mc)->server)));
559
1082
case AVAHI_RESOLVER_FOUND:
561
1084
char ip[AVAHI_ADDRESS_STR_MAX];
562
1085
avahi_address_snprint(ip, sizeof(ip), address);
564
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
565
" port %d\n", name, host_name, ip, port);
1087
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1088
PRIdMAX ") on port %" PRIu16 "\n", name,
1089
host_name, ip, (intmax_t)interface, port);
567
int ret = start_mandos_communication(ip, port, interface);
1091
int ret = start_mandos_communication(ip, (in_port_t)port,
1093
avahi_proto_to_af(proto),
1096
avahi_simple_poll_quit(simple_poll);
1098
if(not add_server(ip, (in_port_t)port, interface,
1099
avahi_proto_to_af(proto),
1100
&((mandos_context*)mc)->current_server)){
1101
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
573
1107
avahi_s_service_resolver_free(r);
576
static void browse_callback(
577
AvahiSServiceBrowser *b,
578
AvahiIfIndex interface,
579
AvahiProtocol protocol,
580
AvahiBrowserEvent event,
584
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
587
AvahiServer *s = userdata;
588
assert(b); /* Spurious warning */
590
/* Called whenever a new services becomes available on the LAN or
591
is removed from the LAN */
1110
static void browse_callback(AvahiSServiceBrowser *b,
1111
AvahiIfIndex interface,
1112
AvahiProtocol protocol,
1113
AvahiBrowserEvent event,
1117
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1124
/* Called whenever a new services becomes available on the LAN or
1125
is removed from the LAN */
1133
case AVAHI_BROWSER_FAILURE:
1135
fprintf_plus(stderr, "(Avahi browser) %s\n",
1136
avahi_strerror(avahi_server_errno
1137
(((mandos_context*)mc)->server)));
1138
avahi_simple_poll_quit(simple_poll);
1141
case AVAHI_BROWSER_NEW:
1142
/* We ignore the returned Avahi resolver object. In the callback
1143
function we free it. If the Avahi server is terminated before
1144
the callback function is called the Avahi server will free the
1147
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1148
interface, protocol, name, type,
1149
domain, protocol, 0,
1150
resolve_callback, mc) == NULL)
1151
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1153
avahi_strerror(avahi_server_errno
1154
(((mandos_context*)mc)->server)));
1157
case AVAHI_BROWSER_REMOVE:
1160
case AVAHI_BROWSER_ALL_FOR_NOW:
1161
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1163
fprintf_plus(stderr, "No Mandos server found, still"
1170
/* Signal handler that stops main loop after SIGTERM */
1171
static void handle_sigterm(int sig){
1176
signal_received = sig;
1177
int old_errno = errno;
1178
/* set main loop to exit */
1179
if(simple_poll != NULL){
1180
avahi_simple_poll_quit(simple_poll);
1185
__attribute__((nonnull, warn_unused_result))
1186
bool get_flags(const char *ifname, struct ifreq *ifr){
1190
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1193
perror_plus("socket");
1197
strcpy(ifr->ifr_name, ifname);
1198
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1202
perror_plus("ioctl SIOCGIFFLAGS");
1210
__attribute__((nonnull, warn_unused_result))
1211
bool good_flags(const char *ifname, const struct ifreq *ifr){
1213
/* Reject the loopback device */
1214
if(ifr->ifr_flags & IFF_LOOPBACK){
1216
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1221
/* Accept point-to-point devices only if connect_to is specified */
1222
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1224
fprintf_plus(stderr, "Accepting point-to-point interface"
1225
" \"%s\"\n", ifname);
1229
/* Otherwise, reject non-broadcast-capable devices */
1230
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1232
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1233
" \"%s\"\n", ifname);
1237
/* Reject non-ARP interfaces (including dummy interfaces) */
1238
if(ifr->ifr_flags & IFF_NOARP){
1240
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1246
/* Accept this device */
1248
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1254
* This function determines if a directory entry in /sys/class/net
1255
* corresponds to an acceptable network device.
1256
* (This function is passed to scandir(3) as a filter function.)
1258
__attribute__((nonnull, warn_unused_result))
1259
int good_interface(const struct dirent *if_entry){
1260
if(if_entry->d_name[0] == '.'){
1265
if(not get_flags(if_entry->d_name, &ifr)){
1267
fprintf_plus(stderr, "Failed to get flags for interface "
1268
"\"%s\"\n", if_entry->d_name);
1273
if(not good_flags(if_entry->d_name, &ifr)){
1280
* This function determines if a network interface is up.
1282
__attribute__((nonnull, warn_unused_result))
1283
bool interface_is_up(const char *interface){
1285
if(not get_flags(interface, &ifr)){
1287
fprintf_plus(stderr, "Failed to get flags for interface "
1288
"\"%s\"\n", interface);
1293
return (bool)(ifr.ifr_flags & IFF_UP);
1297
* This function determines if a network interface is running
1299
__attribute__((nonnull, warn_unused_result))
1300
bool interface_is_running(const char *interface){
1302
if(not get_flags(interface, &ifr)){
1304
fprintf_plus(stderr, "Failed to get flags for interface "
1305
"\"%s\"\n", interface);
1310
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1313
__attribute__((nonnull, pure, warn_unused_result))
1314
int notdotentries(const struct dirent *direntry){
1315
/* Skip "." and ".." */
1316
if(direntry->d_name[0] == '.'
1317
and (direntry->d_name[1] == '\0'
1318
or (direntry->d_name[1] == '.'
1319
and direntry->d_name[2] == '\0'))){
1325
/* Is this directory entry a runnable program? */
1326
__attribute__((nonnull, warn_unused_result))
1327
int runnable_hook(const struct dirent *direntry){
1332
if((direntry->d_name)[0] == '\0'){
1337
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1338
"abcdefghijklmnopqrstuvwxyz"
1341
if((direntry->d_name)[sret] != '\0'){
1342
/* Contains non-allowed characters */
1344
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1350
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1353
perror_plus("Could not stat hook");
1357
if(not (S_ISREG(st.st_mode))){
1358
/* Not a regular file */
1360
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1365
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1366
/* Not executable */
1368
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1374
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1380
__attribute__((nonnull, warn_unused_result))
1381
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1382
mandos_context *mc){
1384
struct timespec now;
1385
struct timespec waited_time;
1386
intmax_t block_time;
1389
if(mc->current_server == NULL){
1391
fprintf_plus(stderr, "Wait until first server is found."
1394
ret = avahi_simple_poll_iterate(s, -1);
1397
fprintf_plus(stderr, "Check current_server if we should run"
1400
/* the current time */
1401
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1403
perror_plus("clock_gettime");
1406
/* Calculating in ms how long time between now and server
1407
who we visted longest time ago. Now - last seen. */
1408
waited_time.tv_sec = (now.tv_sec
1409
- mc->current_server->last_seen.tv_sec);
1410
waited_time.tv_nsec = (now.tv_nsec
1411
- mc->current_server->last_seen.tv_nsec);
1412
/* total time is 10s/10,000ms.
1413
Converting to s from ms by dividing by 1,000,
1414
and ns to ms by dividing by 1,000,000. */
1415
block_time = ((retry_interval
1416
- ((intmax_t)waited_time.tv_sec * 1000))
1417
- ((intmax_t)waited_time.tv_nsec / 1000000));
1420
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1424
if(block_time <= 0){
1425
ret = start_mandos_communication(mc->current_server->ip,
1426
mc->current_server->port,
1427
mc->current_server->if_index,
1428
mc->current_server->af, mc);
1430
avahi_simple_poll_quit(s);
1433
ret = clock_gettime(CLOCK_MONOTONIC,
1434
&mc->current_server->last_seen);
1436
perror_plus("clock_gettime");
1439
mc->current_server = mc->current_server->next;
1440
block_time = 0; /* Call avahi to find new Mandos
1441
servers, but don't block */
1444
ret = avahi_simple_poll_iterate(s, (int)block_time);
1447
if(ret > 0 or errno != EINTR){
1448
return (ret != 1) ? ret : 0;
1454
/* Set effective uid to 0, return errno */
1455
__attribute__((warn_unused_result))
1456
error_t raise_privileges(void){
1457
error_t old_errno = errno;
1458
error_t ret_errno = 0;
1459
if(seteuid(0) == -1){
1461
perror_plus("seteuid");
1467
/* Set effective and real user ID to 0. Return errno. */
1468
__attribute__((warn_unused_result))
1469
error_t raise_privileges_permanently(void){
1470
error_t old_errno = errno;
1471
error_t ret_errno = raise_privileges();
1476
if(setuid(0) == -1){
1478
perror_plus("seteuid");
1484
/* Set effective user ID to unprivileged saved user ID */
1485
__attribute__((warn_unused_result))
1486
error_t lower_privileges(void){
1487
error_t old_errno = errno;
1488
error_t ret_errno = 0;
1489
if(seteuid(uid) == -1){
1491
perror_plus("seteuid");
1497
/* Lower privileges permanently */
1498
__attribute__((warn_unused_result))
1499
error_t lower_privileges_permanently(void){
1500
error_t old_errno = errno;
1501
error_t ret_errno = 0;
1502
if(setuid(uid) == -1){
1504
perror_plus("setuid");
1510
__attribute__((nonnull))
1511
void run_network_hooks(const char *mode, const char *interface,
1513
struct dirent **direntries;
1514
if(hookdir_fd == -1){
1515
hookdir_fd = open(hookdir, O_RDONLY);
1516
if(hookdir_fd == -1){
1517
if(errno == ENOENT){
1519
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1520
" found\n", hookdir);
1523
perror_plus("open");
1529
#if __GLIBC_PREREQ(2, 15)
1530
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1531
runnable_hook, alphasort);
1532
#else /* not __GLIBC_PREREQ(2, 15) */
1533
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1535
#endif /* not __GLIBC_PREREQ(2, 15) */
1536
#else /* not __GLIBC__ */
1537
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1539
#endif /* not __GLIBC__ */
1541
perror_plus("scandir");
1544
struct dirent *direntry;
1546
int devnull = open("/dev/null", O_RDONLY);
1547
for(int i = 0; i < numhooks; i++){
1548
direntry = direntries[i];
1550
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1553
pid_t hook_pid = fork();
1556
/* Raise privileges */
1557
if(raise_privileges_permanently() != 0){
1558
perror_plus("Failed to raise privileges");
1565
perror_plus("setgid");
1568
/* Reset supplementary groups */
1570
ret = setgroups(0, NULL);
1572
perror_plus("setgroups");
1575
ret = dup2(devnull, STDIN_FILENO);
1577
perror_plus("dup2(devnull, STDIN_FILENO)");
1580
ret = close(devnull);
1582
perror_plus("close");
1585
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1587
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1590
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1592
perror_plus("setenv");
1595
ret = setenv("DEVICE", interface, 1);
1597
perror_plus("setenv");
1600
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1602
perror_plus("setenv");
1605
ret = setenv("MODE", mode, 1);
1607
perror_plus("setenv");
1611
ret = asprintf(&delaystring, "%f", (double)delay);
1613
perror_plus("asprintf");
1616
ret = setenv("DELAY", delaystring, 1);
1619
perror_plus("setenv");
1623
if(connect_to != NULL){
1624
ret = setenv("CONNECT", connect_to, 1);
1626
perror_plus("setenv");
1630
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
1632
perror_plus("openat");
1633
_exit(EXIT_FAILURE);
1635
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1636
perror_plus("close");
1637
_exit(EXIT_FAILURE);
1639
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1641
perror_plus("fexecve");
1642
_exit(EXIT_FAILURE);
1646
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1647
perror_plus("waitpid");
1650
if(WIFEXITED(status)){
1651
if(WEXITSTATUS(status) != 0){
1652
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1653
" with status %d\n", direntry->d_name,
1654
WEXITSTATUS(status));
1657
} else if(WIFSIGNALED(status)){
1658
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1659
" signal %d\n", direntry->d_name,
1663
fprintf_plus(stderr, "Warning: network hook \"%s\""
1664
" crashed\n", direntry->d_name);
1669
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1673
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1674
perror_plus("close");
1681
__attribute__((nonnull, warn_unused_result))
1682
error_t bring_up_interface(const char *const interface,
1684
error_t old_errno = errno;
1686
struct ifreq network;
1687
unsigned int if_index = if_nametoindex(interface);
1689
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1699
if(not interface_is_up(interface)){
1700
error_t ret_errno = 0, ioctl_errno = 0;
1701
if(not get_flags(interface, &network)){
1703
fprintf_plus(stderr, "Failed to get flags for interface "
1704
"\"%s\"\n", interface);
1708
network.ifr_flags |= IFF_UP; /* set flag */
1710
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1713
perror_plus("socket");
1719
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1721
perror_plus("close");
1728
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1732
/* Raise privileges */
1733
ret_errno = raise_privileges();
1735
perror_plus("Failed to raise privileges");
1740
bool restore_loglevel = false;
1742
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1743
messages about the network interface to mess up the prompt */
1744
ret_linux = klogctl(8, NULL, 5);
1745
if(ret_linux == -1){
1746
perror_plus("klogctl");
1748
restore_loglevel = true;
1751
#endif /* __linux__ */
1752
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1753
ioctl_errno = errno;
1755
if(restore_loglevel){
1756
ret_linux = klogctl(7, NULL, 0);
1757
if(ret_linux == -1){
1758
perror_plus("klogctl");
1761
#endif /* __linux__ */
1763
/* If raise_privileges() succeeded above */
1765
/* Lower privileges */
1766
ret_errno = lower_privileges();
1769
perror_plus("Failed to lower privileges");
1773
/* Close the socket */
1774
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1776
perror_plus("close");
1779
if(ret_setflags == -1){
1780
errno = ioctl_errno;
1781
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1786
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1790
/* Sleep checking until interface is running.
1791
Check every 0.25s, up to total time of delay */
1792
for(int i=0; i < delay * 4; i++){
1793
if(interface_is_running(interface)){
1796
struct timespec sleeptime = { .tv_nsec = 250000000 };
1797
ret = nanosleep(&sleeptime, NULL);
1798
if(ret == -1 and errno != EINTR){
1799
perror_plus("nanosleep");
1807
__attribute__((nonnull, warn_unused_result))
1808
error_t take_down_interface(const char *const interface){
1809
error_t old_errno = errno;
1810
struct ifreq network;
1811
unsigned int if_index = if_nametoindex(interface);
1813
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1817
if(interface_is_up(interface)){
1818
error_t ret_errno = 0, ioctl_errno = 0;
1819
if(not get_flags(interface, &network) and debug){
1821
fprintf_plus(stderr, "Failed to get flags for interface "
1822
"\"%s\"\n", interface);
1826
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1828
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1831
perror_plus("socket");
1837
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1841
/* Raise privileges */
1842
ret_errno = raise_privileges();
1844
perror_plus("Failed to raise privileges");
1847
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1848
ioctl_errno = errno;
1850
/* If raise_privileges() succeeded above */
1852
/* Lower privileges */
1853
ret_errno = lower_privileges();
1856
perror_plus("Failed to lower privileges");
1860
/* Close the socket */
1861
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1863
perror_plus("close");
1866
if(ret_setflags == -1){
1867
errno = ioctl_errno;
1868
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1873
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1881
int main(int argc, char *argv[]){
1882
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1883
.priority = "SECURE256:!CTYPE-X.509:"
1884
"+CTYPE-OPENPGP", .current_server = NULL,
1885
.interfaces = NULL, .interfaces_size = 0 };
1886
AvahiSServiceBrowser *sb = NULL;
1891
int exitcode = EXIT_SUCCESS;
1892
char *interfaces_to_take_down = NULL;
1893
size_t interfaces_to_take_down_size = 0;
1894
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
1895
char old_tempdir[] = "/tmp/mandosXXXXXX";
1896
char *tempdir = NULL;
1897
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1898
const char *seckey = PATHDIR "/" SECKEY;
1899
const char *pubkey = PATHDIR "/" PUBKEY;
1900
char *interfaces_hooks = NULL;
1902
bool gnutls_initialized = false;
1903
bool gpgme_initialized = false;
1905
double retry_interval = 10; /* 10s between trying a server and
1906
retrying the same server again */
1908
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1909
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1914
/* Lower any group privileges we might have, just to be safe */
1918
perror_plus("setgid");
1921
/* Lower user privileges (temporarily) */
1925
perror_plus("seteuid");
1933
struct argp_option options[] = {
1934
{ .name = "debug", .key = 128,
1935
.doc = "Debug mode", .group = 3 },
1936
{ .name = "connect", .key = 'c',
1937
.arg = "ADDRESS:PORT",
1938
.doc = "Connect directly to a specific Mandos server",
1940
{ .name = "interface", .key = 'i',
1942
.doc = "Network interface that will be used to search for"
1945
{ .name = "seckey", .key = 's',
1947
.doc = "OpenPGP secret key file base name",
1949
{ .name = "pubkey", .key = 'p',
1951
.doc = "OpenPGP public key file base name",
1953
{ .name = "dh-bits", .key = 129,
1955
.doc = "Bit length of the prime number used in the"
1956
" Diffie-Hellman key exchange",
1958
{ .name = "priority", .key = 130,
1960
.doc = "GnuTLS priority string for the TLS handshake",
1962
{ .name = "delay", .key = 131,
1964
.doc = "Maximum delay to wait for interface startup",
1966
{ .name = "retry", .key = 132,
1968
.doc = "Retry interval used when denied by the Mandos server",
1970
{ .name = "network-hook-dir", .key = 133,
1972
.doc = "Directory where network hooks are located",
1975
* These reproduce what we would get without ARGP_NO_HELP
1977
{ .name = "help", .key = '?',
1978
.doc = "Give this help list", .group = -1 },
1979
{ .name = "usage", .key = -3,
1980
.doc = "Give a short usage message", .group = -1 },
1981
{ .name = "version", .key = 'V',
1982
.doc = "Print program version", .group = -1 },
1986
error_t parse_opt(int key, char *arg,
1987
struct argp_state *state){
1990
case 128: /* --debug */
1993
case 'c': /* --connect */
1996
case 'i': /* --interface */
1997
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2000
argp_error(state, "%s", strerror(ret_errno));
2003
case 's': /* --seckey */
2006
case 'p': /* --pubkey */
2009
case 129: /* --dh-bits */
2011
tmpmax = strtoimax(arg, &tmp, 10);
2012
if(errno != 0 or tmp == arg or *tmp != '\0'
2013
or tmpmax != (typeof(mc.dh_bits))tmpmax){
2014
argp_error(state, "Bad number of DH bits");
2016
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2018
case 130: /* --priority */
2021
case 131: /* --delay */
2023
delay = strtof(arg, &tmp);
2024
if(errno != 0 or tmp == arg or *tmp != '\0'){
2025
argp_error(state, "Bad delay");
2027
case 132: /* --retry */
2029
retry_interval = strtod(arg, &tmp);
2030
if(errno != 0 or tmp == arg or *tmp != '\0'
2031
or (retry_interval * 1000) > INT_MAX
2032
or retry_interval < 0){
2033
argp_error(state, "Bad retry interval");
2036
case 133: /* --network-hook-dir */
2040
* These reproduce what we would get without ARGP_NO_HELP
2042
case '?': /* --help */
2043
argp_state_help(state, state->out_stream,
2044
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2045
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2046
case -3: /* --usage */
2047
argp_state_help(state, state->out_stream,
2048
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2049
case 'V': /* --version */
2050
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2051
exit(argp_err_exit_status);
2054
return ARGP_ERR_UNKNOWN;
2059
struct argp argp = { .options = options, .parser = parse_opt,
2061
.doc = "Mandos client -- Get and decrypt"
2062
" passwords from a Mandos server" };
2063
ret = argp_parse(&argp, argc, argv,
2064
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
595
case AVAHI_BROWSER_FAILURE:
597
fprintf(stderr, "(Browser) %s\n",
598
avahi_strerror(avahi_server_errno(server)));
599
avahi_simple_poll_quit(simple_poll);
602
case AVAHI_BROWSER_NEW:
603
/* We ignore the returned resolver object. In the callback
604
function we free it. If the server is terminated before
605
the callback function is called the server will free
606
the resolver for us. */
608
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
610
AVAHI_PROTO_INET6, 0,
611
resolve_callback, s)))
612
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
613
avahi_strerror(avahi_server_errno(s)));
616
case AVAHI_BROWSER_REMOVE:
619
case AVAHI_BROWSER_ALL_FOR_NOW:
620
case AVAHI_BROWSER_CACHE_EXHAUSTED:
625
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
2071
perror_plus("argp_parse");
2072
exitcode = EX_OSERR;
2075
exitcode = EX_USAGE;
2081
/* Work around Debian bug #633582:
2082
<http://bugs.debian.org/633582> */
2084
/* Re-raise privileges */
2085
ret_errno = raise_privileges();
2088
perror_plus("Failed to raise privileges");
2092
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2093
int seckey_fd = open(seckey, O_RDONLY);
2094
if(seckey_fd == -1){
2095
perror_plus("open");
2097
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2099
perror_plus("fstat");
2101
if(S_ISREG(st.st_mode)
2102
and st.st_uid == 0 and st.st_gid == 0){
2103
ret = fchown(seckey_fd, uid, gid);
2105
perror_plus("fchown");
2109
TEMP_FAILURE_RETRY(close(seckey_fd));
2113
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2114
int pubkey_fd = open(pubkey, O_RDONLY);
2115
if(pubkey_fd == -1){
2116
perror_plus("open");
2118
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2120
perror_plus("fstat");
2122
if(S_ISREG(st.st_mode)
2123
and st.st_uid == 0 and st.st_gid == 0){
2124
ret = fchown(pubkey_fd, uid, gid);
2126
perror_plus("fchown");
2130
TEMP_FAILURE_RETRY(close(pubkey_fd));
2134
/* Lower privileges */
2135
ret_errno = lower_privileges();
2138
perror_plus("Failed to lower privileges");
2143
/* Remove invalid interface names (except "none") */
2145
char *interface = NULL;
2146
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2148
if(strcmp(interface, "none") != 0
2149
and if_nametoindex(interface) == 0){
2150
if(interface[0] != '\0'){
2151
fprintf_plus(stderr, "Not using nonexisting interface"
2152
" \"%s\"\n", interface);
2154
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2160
/* Run network hooks */
2162
if(mc.interfaces != NULL){
2163
interfaces_hooks = malloc(mc.interfaces_size);
2164
if(interfaces_hooks == NULL){
2165
perror_plus("malloc");
2168
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2169
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2171
run_network_hooks("start", interfaces_hooks != NULL ?
2172
interfaces_hooks : "", delay);
2176
avahi_set_log_function(empty_log);
2179
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2180
from the signal handler */
2181
/* Initialize the pseudo-RNG for Avahi */
2182
srand((unsigned int) time(NULL));
2183
simple_poll = avahi_simple_poll_new();
2184
if(simple_poll == NULL){
2185
fprintf_plus(stderr,
2186
"Avahi: Failed to create simple poll object.\n");
2187
exitcode = EX_UNAVAILABLE;
2191
sigemptyset(&sigterm_action.sa_mask);
2192
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2194
perror_plus("sigaddset");
2195
exitcode = EX_OSERR;
2198
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2200
perror_plus("sigaddset");
2201
exitcode = EX_OSERR;
2204
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2206
perror_plus("sigaddset");
2207
exitcode = EX_OSERR;
2210
/* Need to check if the handler is SIG_IGN before handling:
2211
| [[info:libc:Initial Signal Actions]] |
2212
| [[info:libc:Basic Signal Handling]] |
2214
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2216
perror_plus("sigaction");
2219
if(old_sigterm_action.sa_handler != SIG_IGN){
2220
ret = sigaction(SIGINT, &sigterm_action, NULL);
2222
perror_plus("sigaction");
2223
exitcode = EX_OSERR;
2227
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2229
perror_plus("sigaction");
2232
if(old_sigterm_action.sa_handler != SIG_IGN){
2233
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2235
perror_plus("sigaction");
2236
exitcode = EX_OSERR;
2240
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2242
perror_plus("sigaction");
2245
if(old_sigterm_action.sa_handler != SIG_IGN){
2246
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2248
perror_plus("sigaction");
2249
exitcode = EX_OSERR;
2254
/* If no interfaces were specified, make a list */
2255
if(mc.interfaces == NULL){
2256
struct dirent **direntries;
2257
/* Look for any good interfaces */
2258
ret = scandir(sys_class_net, &direntries, good_interface,
2261
/* Add all found interfaces to interfaces list */
2262
for(int i = 0; i < ret; ++i){
2263
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2264
direntries[i]->d_name);
2267
perror_plus("argz_add");
2271
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2272
direntries[i]->d_name);
2278
fprintf_plus(stderr, "Could not find a network interface\n");
2279
exitcode = EXIT_FAILURE;
2284
/* Bring up interfaces which are down, and remove any "none"s */
2286
char *interface = NULL;
2287
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2289
/* If interface name is "none", stop bringing up interfaces.
2290
Also remove all instances of "none" from the list */
2291
if(strcmp(interface, "none") == 0){
2292
argz_delete(&mc.interfaces, &mc.interfaces_size,
2295
while((interface = argz_next(mc.interfaces,
2296
mc.interfaces_size, interface))){
2297
if(strcmp(interface, "none") == 0){
2298
argz_delete(&mc.interfaces, &mc.interfaces_size,
2305
bool interface_was_up = interface_is_up(interface);
2306
errno = bring_up_interface(interface, delay);
2307
if(not interface_was_up){
2309
perror_plus("Failed to bring up interface");
2311
errno = argz_add(&interfaces_to_take_down,
2312
&interfaces_to_take_down_size,
2315
perror_plus("argz_add");
2320
if(debug and (interfaces_to_take_down == NULL)){
2321
fprintf_plus(stderr, "No interfaces were brought up\n");
2325
/* If we only got one interface, explicitly use only that one */
2326
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2328
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2331
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2338
ret = init_gnutls_global(pubkey, seckey, &mc);
2340
fprintf_plus(stderr, "init_gnutls_global failed\n");
2341
exitcode = EX_UNAVAILABLE;
2344
gnutls_initialized = true;
2351
/* Try /run/tmp before /tmp */
2352
tempdir = mkdtemp(run_tempdir);
2353
if(tempdir == NULL and errno == ENOENT){
2355
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2356
run_tempdir, old_tempdir);
2358
tempdir = mkdtemp(old_tempdir);
2360
if(tempdir == NULL){
2361
perror_plus("mkdtemp");
2369
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2370
fprintf_plus(stderr, "init_gpgme failed\n");
2371
exitcode = EX_UNAVAILABLE;
2374
gpgme_initialized = true;
2381
if(connect_to != NULL){
2382
/* Connect directly, do not use Zeroconf */
2383
/* (Mainly meant for debugging) */
2384
char *address = strrchr(connect_to, ':');
2386
if(address == NULL){
2387
fprintf_plus(stderr, "No colon in address\n");
2388
exitcode = EX_USAGE;
2398
tmpmax = strtoimax(address+1, &tmp, 10);
2399
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2400
or tmpmax != (in_port_t)tmpmax){
2401
fprintf_plus(stderr, "Bad port number\n");
2402
exitcode = EX_USAGE;
2410
port = (in_port_t)tmpmax;
2412
/* Colon in address indicates IPv6 */
2414
if(strchr(connect_to, ':') != NULL){
2416
/* Accept [] around IPv6 address - see RFC 5952 */
2417
if(connect_to[0] == '[' and address[-1] == ']')
2425
address = connect_to;
2431
while(not quit_now){
2432
ret = start_mandos_communication(address, port, if_index, af,
2434
if(quit_now or ret == 0){
2438
fprintf_plus(stderr, "Retrying in %d seconds\n",
2439
(int)retry_interval);
2441
sleep((unsigned int)retry_interval);
2445
exitcode = EXIT_SUCCESS;
626
2456
AvahiServerConfig config;
627
AvahiSServiceBrowser *sb = NULL;
630
int returncode = EXIT_SUCCESS;
631
const char *interface = NULL;
632
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
633
char *connect_to = NULL;
636
static struct option long_options[] = {
637
{"debug", no_argument, (int *)&debug, 1},
638
{"connect", required_argument, 0, 'c'},
639
{"interface", required_argument, 0, 'i'},
642
int option_index = 0;
643
ret = getopt_long (argc, argv, "i:", long_options,
664
if(interface != NULL){
665
if_index = (AvahiIfIndex) if_nametoindex(interface);
667
fprintf(stderr, "No such interface: \"%s\"\n", interface);
672
if(connect_to != NULL){
673
/* Connect directly, do not use Zeroconf */
674
/* (Mainly meant for debugging) */
675
char *address = strrchr(connect_to, ':');
677
fprintf(stderr, "No colon in address\n");
681
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
683
perror("Bad port number");
687
address = connect_to;
688
ret = start_mandos_communication(address, port, if_index);
697
avahi_set_log_function(empty_log);
700
/* Initialize the psuedo-RNG */
701
srand((unsigned int) time(NULL));
703
/* Allocate main loop object */
704
if (!(simple_poll = avahi_simple_poll_new())) {
705
fprintf(stderr, "Failed to create simple poll object.\n");
710
/* Do not publish any local records */
2457
/* Do not publish any local Zeroconf records */
711
2458
avahi_server_config_init(&config);
712
2459
config.publish_hinfo = 0;
713
2460
config.publish_addresses = 0;
714
2461
config.publish_workstation = 0;
715
2462
config.publish_domain = 0;
717
2464
/* Allocate a new server */
718
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
719
&config, NULL, NULL, &error);
721
/* Free the configuration data */
2465
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2466
&config, NULL, NULL, &ret_errno);
2468
/* Free the Avahi configuration data */
722
2469
avahi_server_config_free(&config);
724
/* Check if creating the server object succeeded */
726
fprintf(stderr, "Failed to create server: %s\n",
727
avahi_strerror(error));
728
returncode = EXIT_FAILURE;
732
/* Create the service browser */
733
sb = avahi_s_service_browser_new(server, if_index,
735
"_mandos._tcp", NULL, 0,
736
browse_callback, server);
738
fprintf(stderr, "Failed to create service browser: %s\n",
739
avahi_strerror(avahi_server_errno(server)));
740
returncode = EXIT_FAILURE;
744
/* Run the main loop */
747
fprintf(stderr, "Starting avahi loop search\n");
750
avahi_simple_poll_loop(simple_poll);
755
fprintf(stderr, "%s exiting\n", argv[0]);
760
avahi_s_service_browser_free(sb);
763
avahi_server_free(server);
766
avahi_simple_poll_free(simple_poll);
2472
/* Check if creating the Avahi server object succeeded */
2473
if(mc.server == NULL){
2474
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2475
avahi_strerror(ret_errno));
2476
exitcode = EX_UNAVAILABLE;
2484
/* Create the Avahi service browser */
2485
sb = avahi_s_service_browser_new(mc.server, if_index,
2486
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2487
NULL, 0, browse_callback,
2490
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2491
avahi_strerror(avahi_server_errno(mc.server)));
2492
exitcode = EX_UNAVAILABLE;
2500
/* Run the main loop */
2503
fprintf_plus(stderr, "Starting Avahi loop search\n");
2506
ret = avahi_loop_with_timeout(simple_poll,
2507
(int)(retry_interval * 1000), &mc);
2509
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2510
(ret == 0) ? "successfully" : "with error");
2516
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2519
/* Cleanup things */
2520
free(mc.interfaces);
2523
avahi_s_service_browser_free(sb);
2525
if(mc.server != NULL)
2526
avahi_server_free(mc.server);
2528
if(simple_poll != NULL)
2529
avahi_simple_poll_free(simple_poll);
2531
if(gnutls_initialized){
2532
gnutls_certificate_free_credentials(mc.cred);
2533
gnutls_global_deinit();
2534
gnutls_dh_params_deinit(mc.dh_params);
2537
if(gpgme_initialized){
2538
gpgme_release(mc.ctx);
2541
/* Cleans up the circular linked list of Mandos servers the client
2543
if(mc.current_server != NULL){
2544
mc.current_server->prev->next = NULL;
2545
while(mc.current_server != NULL){
2546
server *next = mc.current_server->next;
2547
free(mc.current_server);
2548
mc.current_server = next;
2552
/* Re-raise privileges */
2554
ret_errno = raise_privileges();
2556
perror_plus("Failed to raise privileges");
2559
/* Run network hooks */
2560
run_network_hooks("stop", interfaces_hooks != NULL ?
2561
interfaces_hooks : "", delay);
2563
/* Take down the network interfaces which were brought up */
2565
char *interface = NULL;
2566
while((interface=argz_next(interfaces_to_take_down,
2567
interfaces_to_take_down_size,
2569
ret_errno = take_down_interface(interface);
2572
perror_plus("Failed to take down interface");
2575
if(debug and (interfaces_to_take_down == NULL)){
2576
fprintf_plus(stderr, "No interfaces needed to be taken"
2582
ret_errno = lower_privileges_permanently();
2584
perror_plus("Failed to lower privileges permanently");
2588
free(interfaces_to_take_down);
2589
free(interfaces_hooks);
2591
/* Removes the GPGME temp directory and all files inside */
2592
if(tempdir != NULL){
2593
struct dirent **direntries = NULL;
2594
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY));
2595
if(tempdir_fd == -1){
2596
perror_plus("open");
2599
#if __GLIBC_PREREQ(2, 15)
2600
int numentries = scandirat(tempdir_fd, ".", &direntries,
2601
notdotentries, alphasort);
2602
#else /* not __GLIBC_PREREQ(2, 15) */
2603
int numentries = scandir(tempdir, &direntries, notdotentries,
2605
#endif /* not __GLIBC_PREREQ(2, 15) */
2606
#else /* not __GLIBC__ */
2607
int numentries = scandir(tempdir, &direntries, notdotentries,
2609
#endif /* not __GLIBC__ */
2611
for(int i = 0; i < numentries; i++){
2612
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2614
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2615
" \"%s\", 0): %s\n", tempdir,
2616
direntries[i]->d_name, strerror(errno));
2620
/* need to clean even if 0 because man page doesn't specify */
2622
if(numentries == -1){
2623
perror_plus("scandir");
2625
ret = rmdir(tempdir);
2626
if(ret == -1 and errno != ENOENT){
2627
perror_plus("rmdir");
2630
TEMP_FAILURE_RETRY(close(tempdir_fd));
2635
sigemptyset(&old_sigterm_action.sa_mask);
2636
old_sigterm_action.sa_handler = SIG_DFL;
2637
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2638
&old_sigterm_action,
2641
perror_plus("sigaction");
2644
ret = raise(signal_received);
2645
} while(ret != 0 and errno == EINTR);
2647
perror_plus("raise");
2650
TEMP_FAILURE_RETRY(pause());