110
47
#include <avahi-common/malloc.h>
111
48
#include <avahi-common/error.h>
114
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
117
init_gnutls_session(),
119
#include <gnutls/openpgp.h>
120
/* gnutls_certificate_set_openpgp_key_file(),
121
GNUTLS_OPENPGP_FMT_BASE64 */
124
#include <gpgme.h> /* All GPGME types, constants and
127
GPGME_PROTOCOL_OpenPGP,
51
#include <sys/types.h> /* socket(), inet_pton() */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton() */
54
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
55
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
57
#include <unistd.h> /* close() */
58
#include <netinet/in.h>
59
#include <stdbool.h> /* true */
60
#include <string.h> /* memset */
61
#include <arpa/inet.h> /* inet_pton() */
62
#include <iso646.h> /* not */
65
#include <errno.h> /* perror() */
72
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
74
#define CERTFILE CERT_ROOT "openpgp-client.txt"
75
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
130
76
#define BUFFER_SIZE 256
132
#define PATHDIR "/conf/conf.d/mandos"
133
#define SECKEY "seckey.txt"
134
#define PUBKEY "pubkey.txt"
135
#define HOOKDIR "/lib/mandos/network-hooks.d"
137
79
bool debug = false;
138
static const char mandos_protocol_version[] = "1";
139
const char *argp_program_version = "mandos-client " VERSION;
140
const char *argp_program_bug_address = "<mandos@recompile.se>";
141
static const char sys_class_net[] = "/sys/class/net";
142
char *connect_to = NULL;
143
const char *hookdir = HOOKDIR;
147
/* Doubly linked list that need to be circularly linked when used */
148
typedef struct server{
151
AvahiIfIndex if_index;
153
struct timespec last_seen;
158
/* Used for passing in values through the Avahi callback functions */
82
gnutls_session_t session;
161
83
gnutls_certificate_credentials_t cred;
162
unsigned int dh_bits;
163
84
gnutls_dh_params_t dh_params;
164
const char *priority;
88
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
89
char **new_packet, const char *homedir){
90
gpgme_data_t dh_crypto, dh_plain;
166
server *current_server;
168
size_t interfaces_size;
171
/* global so signal handler can reach it*/
172
AvahiSimplePoll *simple_poll;
174
sig_atomic_t quit_now = 0;
175
int signal_received = 0;
177
/* Function to use when printing errors */
178
void perror_plus(const char *print_text){
180
fprintf(stderr, "Mandos plugin %s: ",
181
program_invocation_short_name);
186
__attribute__((format (gnu_printf, 2, 3), nonnull))
187
int fprintf_plus(FILE *stream, const char *format, ...){
189
va_start (ap, format);
191
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
192
program_invocation_short_name));
193
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
197
* Make additional room in "buffer" for at least BUFFER_SIZE more
198
* bytes. "buffer_capacity" is how much is currently allocated,
199
* "buffer_length" is how much is already used.
201
__attribute__((nonnull, warn_unused_result))
202
size_t incbuffer(char **buffer, size_t buffer_length,
203
size_t buffer_capacity){
204
if(buffer_length + BUFFER_SIZE > buffer_capacity){
205
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
207
int old_errno = errno;
214
buffer_capacity += BUFFER_SIZE;
216
return buffer_capacity;
219
/* Add server to set of servers to retry periodically */
220
__attribute__((nonnull, warn_unused_result))
221
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
222
int af, server **current_server){
224
server *new_server = malloc(sizeof(server));
225
if(new_server == NULL){
226
perror_plus("malloc");
229
*new_server = (server){ .ip = strdup(ip),
231
.if_index = if_index,
233
if(new_server->ip == NULL){
234
perror_plus("strdup");
237
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
239
perror_plus("clock_gettime");
242
/* Special case of first server */
243
if(*current_server == NULL){
244
new_server->next = new_server;
245
new_server->prev = new_server;
246
*current_server = new_server;
248
/* Place the new server last in the list */
249
new_server->next = *current_server;
250
new_server->prev = (*current_server)->prev;
251
new_server->prev->next = new_server;
252
(*current_server)->prev = new_server;
260
__attribute__((nonnull, warn_unused_result))
261
static bool init_gpgme(const char * const seckey,
262
const char * const pubkey,
263
const char * const tempdir,
94
ssize_t new_packet_capacity = 0;
95
ssize_t new_packet_length = 0;
266
96
gpgme_engine_info_t engine_info;
269
* Helper function to insert pub and seckey to the engine keyring.
271
bool import_key(const char * const filename){
274
gpgme_data_t pgp_data;
276
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
282
rc = gpgme_data_new_from_fd(&pgp_data, fd);
283
if(rc != GPG_ERR_NO_ERROR){
284
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
285
gpgme_strsource(rc), gpgme_strerror(rc));
289
rc = gpgme_op_import(mc->ctx, pgp_data);
290
if(rc != GPG_ERR_NO_ERROR){
291
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
292
gpgme_strsource(rc), gpgme_strerror(rc));
296
ret = (int)TEMP_FAILURE_RETRY(close(fd));
298
perror_plus("close");
300
gpgme_data_release(pgp_data);
305
fprintf_plus(stderr, "Initializing GPGME\n");
99
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
309
103
gpgme_check_version(NULL);
310
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
311
if(rc != GPG_ERR_NO_ERROR){
312
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
313
gpgme_strsource(rc), gpgme_strerror(rc));
104
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
317
/* Set GPGME home directory for the OpenPGP engine only */
318
rc = gpgme_get_engine_info(&engine_info);
319
if(rc != GPG_ERR_NO_ERROR){
320
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
321
gpgme_strsource(rc), gpgme_strerror(rc));
106
/* Set GPGME home directory */
107
rc = gpgme_get_engine_info (&engine_info);
108
if (rc != GPG_ERR_NO_ERROR){
109
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
110
gpgme_strsource(rc), gpgme_strerror(rc));
324
113
while(engine_info != NULL){
325
114
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
326
115
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
327
engine_info->file_name, tempdir);
116
engine_info->file_name, homedir);
330
119
engine_info = engine_info->next;
332
121
if(engine_info == NULL){
333
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
338
/* Create new GPGME "context" */
339
rc = gpgme_new(&(mc->ctx));
340
if(rc != GPG_ERR_NO_ERROR){
341
fprintf_plus(stderr, "Mandos plugin mandos-client: "
342
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
347
if(not import_key(pubkey) or not import_key(seckey)){
355
* Decrypt OpenPGP data.
356
* Returns -1 on error
358
__attribute__((nonnull, warn_unused_result))
359
static ssize_t pgp_packet_decrypt(const char *cryptotext,
363
gpgme_data_t dh_crypto, dh_plain;
366
size_t plaintext_capacity = 0;
367
ssize_t plaintext_length = 0;
370
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
373
/* Create new GPGME data buffer from memory cryptotext */
374
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
376
if(rc != GPG_ERR_NO_ERROR){
377
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
378
gpgme_strsource(rc), gpgme_strerror(rc));
122
fprintf(stderr, "Could not set home dir to %s\n", homedir);
126
/* Create new GPGME data buffer from packet buffer */
127
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
128
if (rc != GPG_ERR_NO_ERROR){
129
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
130
gpgme_strsource(rc), gpgme_strerror(rc));
382
134
/* Create new empty GPGME data buffer for the plaintext */
383
135
rc = gpgme_data_new(&dh_plain);
384
if(rc != GPG_ERR_NO_ERROR){
385
fprintf_plus(stderr, "Mandos plugin mandos-client: "
386
"bad gpgme_data_new: %s: %s\n",
387
gpgme_strsource(rc), gpgme_strerror(rc));
388
gpgme_data_release(dh_crypto);
392
/* Decrypt data from the cryptotext data buffer to the plaintext
394
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
395
if(rc != GPG_ERR_NO_ERROR){
396
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
397
gpgme_strsource(rc), gpgme_strerror(rc));
398
plaintext_length = -1;
400
gpgme_decrypt_result_t result;
401
result = gpgme_op_decrypt_result(mc->ctx);
403
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
405
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
406
result->unsupported_algorithm);
407
fprintf_plus(stderr, "Wrong key usage: %u\n",
408
result->wrong_key_usage);
409
if(result->file_name != NULL){
410
fprintf_plus(stderr, "File name: %s\n", result->file_name);
412
gpgme_recipient_t recipient;
413
recipient = result->recipients;
136
if (rc != GPG_ERR_NO_ERROR){
137
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
138
gpgme_strsource(rc), gpgme_strerror(rc));
142
/* Create new GPGME "context" */
143
rc = gpgme_new(&ctx);
144
if (rc != GPG_ERR_NO_ERROR){
145
fprintf(stderr, "bad gpgme_new: %s: %s\n",
146
gpgme_strsource(rc), gpgme_strerror(rc));
150
/* Decrypt data from the FILE pointer to the plaintext data
152
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
153
if (rc != GPG_ERR_NO_ERROR){
154
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
155
gpgme_strsource(rc), gpgme_strerror(rc));
160
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
164
gpgme_decrypt_result_t result;
165
result = gpgme_op_decrypt_result(ctx);
167
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
169
fprintf(stderr, "Unsupported algorithm: %s\n",
170
result->unsupported_algorithm);
171
fprintf(stderr, "Wrong key usage: %d\n",
172
result->wrong_key_usage);
173
if(result->file_name != NULL){
174
fprintf(stderr, "File name: %s\n", result->file_name);
176
gpgme_recipient_t recipient;
177
recipient = result->recipients;
414
179
while(recipient != NULL){
415
fprintf_plus(stderr, "Public key algorithm: %s\n",
416
gpgme_pubkey_algo_name
417
(recipient->pubkey_algo));
418
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
419
fprintf_plus(stderr, "Secret key available: %s\n",
420
recipient->status == GPG_ERR_NO_SECKEY
180
fprintf(stderr, "Public key algorithm: %s\n",
181
gpgme_pubkey_algo_name(recipient->pubkey_algo));
182
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
183
fprintf(stderr, "Secret key available: %s\n",
184
recipient->status == GPG_ERR_NO_SECKEY
422
186
recipient = recipient->next;
430
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
192
/* Delete the GPGME FILE pointer cryptotext data buffer */
193
gpgme_data_release(dh_crypto);
433
195
/* Seek back to the beginning of the GPGME plaintext data buffer */
434
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
435
perror_plus("gpgme_data_seek");
436
plaintext_length = -1;
196
gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
442
plaintext_capacity = incbuffer(plaintext,
443
(size_t)plaintext_length,
445
if(plaintext_capacity == 0){
446
perror_plus("incbuffer");
447
plaintext_length = -1;
200
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
201
*new_packet = realloc(*new_packet,
202
(unsigned int)new_packet_capacity
204
if (*new_packet == NULL){
208
new_packet_capacity += BUFFER_SIZE;
451
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
211
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
453
213
/* Print the data, if any */
459
perror_plus("gpgme_data_read");
460
plaintext_length = -1;
463
plaintext_length += ret;
467
fprintf_plus(stderr, "Decrypted password is: ");
468
for(ssize_t i = 0; i < plaintext_length; i++){
469
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
471
fprintf(stderr, "\n");
476
/* Delete the GPGME cryptotext data buffer */
477
gpgme_data_release(dh_crypto);
218
perror("gpgme_data_read");
221
new_packet_length += ret;
224
/* FIXME: check characters before printing to screen so to not print
225
terminal control characters */
227
/* fprintf(stderr, "decrypted password is: "); */
228
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
229
/* fprintf(stderr, "\n"); */
479
232
/* Delete the GPGME plaintext data buffer */
480
233
gpgme_data_release(dh_plain);
481
return plaintext_length;
234
return new_packet_length;
484
__attribute__((warn_unused_result))
485
static const char *safer_gnutls_strerror(int value){
486
const char *ret = gnutls_strerror(value);
237
static const char * safer_gnutls_strerror (int value) {
238
const char *ret = gnutls_strerror (value);
488
240
ret = "(unknown)";
492
/* GnuTLS log function callback */
493
__attribute__((nonnull))
494
static void debuggnutls(__attribute__((unused)) int level,
496
fprintf_plus(stderr, "GnuTLS: %s", string);
244
void debuggnutls(__attribute__((unused)) int level,
246
fprintf(stderr, "%s", string);
499
__attribute__((nonnull, warn_unused_result))
500
static int init_gnutls_global(const char *pubkeyfilename,
501
const char *seckeyfilename,
249
int initgnutls(encrypted_session *es){
506
fprintf_plus(stderr, "Initializing GnuTLS\n");
254
fprintf(stderr, "Initializing GnuTLS\n");
509
ret = gnutls_global_init();
510
if(ret != GNUTLS_E_SUCCESS){
511
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
512
safer_gnutls_strerror(ret));
257
if ((ret = gnutls_global_init ())
258
!= GNUTLS_E_SUCCESS) {
259
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
517
/* "Use a log level over 10 to enable all debugging options."
520
264
gnutls_global_set_log_level(11);
521
265
gnutls_global_set_log_function(debuggnutls);
524
/* OpenPGP credentials */
525
ret = gnutls_certificate_allocate_credentials(&mc->cred);
526
if(ret != GNUTLS_E_SUCCESS){
527
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
528
safer_gnutls_strerror(ret));
529
gnutls_global_deinit();
268
/* openpgp credentials */
269
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
270
!= GNUTLS_E_SUCCESS) {
271
fprintf (stderr, "memory error: %s\n",
272
safer_gnutls_strerror(ret));
534
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
535
" secret key %s as GnuTLS credentials\n",
277
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
278
" and keyfile %s as GnuTLS credentials\n", CERTFILE,
540
282
ret = gnutls_certificate_set_openpgp_key_file
541
(mc->cred, pubkeyfilename, seckeyfilename,
542
GNUTLS_OPENPGP_FMT_BASE64);
543
if(ret != GNUTLS_E_SUCCESS){
545
"Error[%d] while reading the OpenPGP key pair ('%s',"
546
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
547
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
548
safer_gnutls_strerror(ret));
552
/* GnuTLS server initialization */
553
ret = gnutls_dh_params_init(&mc->dh_params);
554
if(ret != GNUTLS_E_SUCCESS){
555
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
556
" initialization: %s\n",
557
safer_gnutls_strerror(ret));
560
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
561
if(ret != GNUTLS_E_SUCCESS){
562
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
563
safer_gnutls_strerror(ret));
567
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
573
gnutls_certificate_free_credentials(mc->cred);
574
gnutls_global_deinit();
575
gnutls_dh_params_deinit(mc->dh_params);
579
__attribute__((nonnull, warn_unused_result))
580
static int init_gnutls_session(gnutls_session_t *session,
583
/* GnuTLS session creation */
585
ret = gnutls_init(session, GNUTLS_SERVER);
589
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
590
if(ret != GNUTLS_E_SUCCESS){
592
"Error in GnuTLS session initialization: %s\n",
593
safer_gnutls_strerror(ret));
599
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
601
gnutls_deinit(*session);
604
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
605
if(ret != GNUTLS_E_SUCCESS){
606
fprintf_plus(stderr, "Syntax error at: %s\n", err);
607
fprintf_plus(stderr, "GnuTLS error: %s\n",
608
safer_gnutls_strerror(ret));
609
gnutls_deinit(*session);
615
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
618
gnutls_deinit(*session);
621
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
622
if(ret != GNUTLS_E_SUCCESS){
623
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
624
safer_gnutls_strerror(ret));
625
gnutls_deinit(*session);
283
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
284
if (ret != GNUTLS_E_SUCCESS) {
286
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
288
ret, CERTFILE, KEYFILE);
289
fprintf(stdout, "The Error is: %s\n",
290
safer_gnutls_strerror(ret));
294
//GnuTLS server initialization
295
if ((ret = gnutls_dh_params_init (&es->dh_params))
296
!= GNUTLS_E_SUCCESS) {
297
fprintf (stderr, "Error in dh parameter initialization: %s\n",
298
safer_gnutls_strerror(ret));
302
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
303
!= GNUTLS_E_SUCCESS) {
304
fprintf (stderr, "Error in prime generation: %s\n",
305
safer_gnutls_strerror(ret));
309
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
311
// GnuTLS session creation
312
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
313
!= GNUTLS_E_SUCCESS){
314
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
315
safer_gnutls_strerror(ret));
318
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
319
!= GNUTLS_E_SUCCESS) {
320
fprintf(stderr, "Syntax error at: %s\n", err);
321
fprintf(stderr, "GnuTLS error: %s\n",
322
safer_gnutls_strerror(ret));
326
if ((ret = gnutls_credentials_set
327
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
328
!= GNUTLS_E_SUCCESS) {
329
fprintf(stderr, "Error setting a credentials set: %s\n",
330
safer_gnutls_strerror(ret));
629
334
/* ignore client certificate if any. */
630
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
335
gnutls_certificate_server_set_request (es->session,
632
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
338
gnutls_dh_set_prime_bits (es->session, DH_BITS);
637
/* Avahi log function callback */
638
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
639
__attribute__((unused)) const char *txt){}
343
void empty_log(__attribute__((unused)) AvahiLogLevel level,
344
__attribute__((unused)) const char *txt){}
641
/* Called when a Mandos server is found */
642
__attribute__((nonnull, warn_unused_result))
643
static int start_mandos_communication(const char *ip, in_port_t port,
644
AvahiIfIndex if_index,
645
int af, mandos_context *mc){
646
int ret, tcp_sd = -1;
648
struct sockaddr_storage to;
346
int start_mandos_communication(const char *ip, uint16_t port,
347
unsigned int if_index){
349
struct sockaddr_in6 to;
350
encrypted_session es;
649
351
char *buffer = NULL;
650
char *decrypted_buffer = NULL;
352
char *decrypted_buffer;
651
353
size_t buffer_length = 0;
652
354
size_t buffer_capacity = 0;
655
gnutls_session_t session;
656
int pf; /* Protocol family */
673
fprintf_plus(stderr, "Bad address family: %d\n", af);
678
/* If the interface is specified and we have a list of interfaces */
679
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
680
/* Check if the interface is one of the interfaces we are using */
683
char *interface = NULL;
684
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
686
if(if_nametoindex(interface) == (unsigned int)if_index){
693
/* This interface does not match any in the list, so we don't
694
connect to the server */
696
char interface[IF_NAMESIZE];
697
if(if_indextoname((unsigned int)if_index, interface) == NULL){
698
perror_plus("if_indextoname");
700
fprintf_plus(stderr, "Skipping server on non-used interface"
702
if_indextoname((unsigned int)if_index,
710
ret = init_gnutls_session(&session, mc);
716
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
717
PRIuMAX "\n", ip, (uintmax_t)port);
720
tcp_sd = socket(pf, SOCK_STREAM, 0);
723
perror_plus("socket");
733
memset(&to, 0, sizeof(to));
735
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
736
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
738
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
739
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
743
perror_plus("inet_pton");
355
ssize_t decrypted_buffer_size;
358
char interface[IF_NAMESIZE];
361
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
364
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
370
if(if_indextoname(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);
749
fprintf_plus(stderr, "Bad address: %s\n", ip);
754
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
755
if(IN6_IS_ADDR_LINKLOCAL
756
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
757
if(if_index == AVAHI_IF_UNSPEC){
758
fprintf_plus(stderr, "An IPv6 link-local address is"
759
" incomplete without a network interface\n");
763
/* Set the network interface number as scope */
764
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
767
((struct sockaddr_in *)&to)->sin_port = htons(port);
776
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
777
char interface[IF_NAMESIZE];
778
if(if_indextoname((unsigned int)if_index, interface) == NULL){
779
perror_plus("if_indextoname");
781
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
782
"\n", ip, interface, (uintmax_t)port);
785
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
786
ip, (uintmax_t)port);
788
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
789
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
791
ret = getnameinfo((struct sockaddr *)&to,
792
sizeof(struct sockaddr_in6),
793
addrstr, sizeof(addrstr), NULL, 0,
796
ret = getnameinfo((struct sockaddr *)&to,
797
sizeof(struct sockaddr_in),
798
addrstr, sizeof(addrstr), NULL, 0,
801
if(ret == EAI_SYSTEM){
802
perror_plus("getnameinfo");
803
} else if(ret != 0) {
804
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
805
} else if(strcmp(addrstr, ip) != 0){
806
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
816
ret = connect(tcp_sd, (struct sockaddr *)&to,
817
sizeof(struct sockaddr_in6));
819
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
820
sizeof(struct sockaddr_in));
823
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
825
perror_plus("connect");
836
const char *out = mandos_protocol_version;
839
size_t out_size = strlen(out);
840
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
841
out_size - written));
844
perror_plus("write");
848
written += (size_t)ret;
849
if(written < out_size){
852
if(out == mandos_protocol_version){
867
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
875
/* This casting via intptr_t is to eliminate warning about casting
876
an int to a pointer type. This is exactly how the GnuTLS Guile
877
function "set-session-transport-fd!" does it. */
878
gnutls_transport_set_ptr(session,
879
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
887
ret = gnutls_handshake(session);
892
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
894
if(ret != GNUTLS_E_SUCCESS){
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\n", ip);
400
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
406
ret = initgnutls (&es);
412
gnutls_transport_set_ptr (es.session,
413
(gnutls_transport_ptr_t) tcp_sd);
416
fprintf(stderr, "Establishing TLS session with %s\n", ip);
419
ret = gnutls_handshake (es.session);
421
if (ret != GNUTLS_E_SUCCESS){
896
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
423
fprintf(stderr, "\n*** Handshake failed ***\n");
903
/* Read OpenPGP packet that contains the wanted password */
430
//Retrieve OpenPGP packet that contains the wanted password
906
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
433
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
917
buffer_capacity = incbuffer(&buffer, buffer_length,
919
if(buffer_capacity == 0){
921
perror_plus("incbuffer");
931
sret = gnutls_record_recv(session, buffer+buffer_length,
438
if (buffer_length + BUFFER_SIZE > buffer_capacity){
439
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
444
buffer_capacity += BUFFER_SIZE;
447
ret = gnutls_record_recv
448
(es.session, buffer+buffer_length, BUFFER_SIZE);
938
454
case GNUTLS_E_INTERRUPTED:
939
455
case GNUTLS_E_AGAIN:
941
457
case GNUTLS_E_REHANDSHAKE:
943
ret = gnutls_handshake(session);
949
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
951
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
458
ret = gnutls_handshake (es.session);
460
fprintf(stderr, "\n*** Handshake failed ***\n");
959
fprintf_plus(stderr, "Unknown error while reading data from"
960
" encrypted session with Mandos server\n");
961
gnutls_bye(session, GNUTLS_SHUT_RDWR);
467
fprintf(stderr, "Unknown error while reading data from"
468
" encrypted session with mandos server\n");
470
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
966
buffer_length += (size_t) sret;
971
fprintf_plus(stderr, "Closing TLS session\n");
980
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
985
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
987
if(buffer_length > 0){
988
ssize_t decrypted_buffer_size;
989
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
990
&decrypted_buffer, mc);
991
if(decrypted_buffer_size >= 0){
994
while(written < (size_t) decrypted_buffer_size){
1000
ret = (int)fwrite(decrypted_buffer + written, 1,
1001
(size_t)decrypted_buffer_size - written,
474
buffer_length += (size_t) ret;
478
if (buffer_length > 0){
479
decrypted_buffer_size = pgp_packet_decrypt(buffer,
483
if (decrypted_buffer_size >= 0){
484
while(written < decrypted_buffer_size){
485
ret = (int)fwrite (decrypted_buffer + written, 1,
486
(size_t)decrypted_buffer_size - written,
1003
488
if(ret == 0 and ferror(stdout)){
1006
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
490
fprintf(stderr, "Error writing encrypted data: %s\n",
1012
496
written += (size_t)ret;
1018
/* Shutdown procedure */
1023
free(decrypted_buffer);
1026
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1032
perror_plus("close");
1034
gnutls_deinit(session);
498
free(decrypted_buffer);
507
fprintf(stderr, "Closing TLS session\n");
511
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
514
gnutls_deinit (es.session);
515
gnutls_certificate_free_credentials (es.cred);
516
gnutls_global_deinit ();
1044
__attribute__((nonnull))
1045
static void resolve_callback(AvahiSServiceResolver *r,
1046
AvahiIfIndex interface,
1047
AvahiProtocol proto,
1048
AvahiResolverEvent event,
1052
const char *host_name,
1053
const AvahiAddress *address,
1055
AVAHI_GCC_UNUSED AvahiStringList *txt,
1056
AVAHI_GCC_UNUSED AvahiLookupResultFlags
520
static AvahiSimplePoll *simple_poll = NULL;
521
static AvahiServer *server = NULL;
523
static void resolve_callback(
524
AvahiSServiceResolver *r,
525
AvahiIfIndex interface,
526
AVAHI_GCC_UNUSED AvahiProtocol protocol,
527
AvahiResolverEvent event,
531
const char *host_name,
532
const AvahiAddress *address,
534
AVAHI_GCC_UNUSED AvahiStringList *txt,
535
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
536
AVAHI_GCC_UNUSED void* userdata) {
538
assert(r); /* Spurious warning */
1063
540
/* Called whenever a service has been resolved successfully or
1072
545
case AVAHI_RESOLVER_FAILURE:
1073
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1074
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1076
avahi_strerror(avahi_server_errno
1077
(((mandos_context*)mc)->server)));
546
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
547
" type '%s' in domain '%s': %s\n", name, type, domain,
548
avahi_strerror(avahi_server_errno(server)));
1080
551
case AVAHI_RESOLVER_FOUND:
1082
553
char ip[AVAHI_ADDRESS_STR_MAX];
1083
554
avahi_address_snprint(ip, sizeof(ip), address);
1085
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1086
PRIdMAX ") on port %" PRIu16 "\n", name,
1087
host_name, ip, (intmax_t)interface, port);
556
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
557
" port %d\n", name, host_name, ip, port);
1089
int ret = start_mandos_communication(ip, (in_port_t)port,
1091
avahi_proto_to_af(proto),
1094
avahi_simple_poll_quit(simple_poll);
1096
if(not add_server(ip, (in_port_t)port, interface,
1097
avahi_proto_to_af(proto),
1098
&((mandos_context*)mc)->current_server)){
1099
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
559
int ret = start_mandos_communication(ip, port,
560
(unsigned int) interface);
1105
566
avahi_s_service_resolver_free(r);
1108
static void browse_callback(AvahiSServiceBrowser *b,
1109
AvahiIfIndex interface,
1110
AvahiProtocol protocol,
1111
AvahiBrowserEvent event,
1115
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1122
/* Called whenever a new services becomes available on the LAN or
1123
is removed from the LAN */
1131
case AVAHI_BROWSER_FAILURE:
1133
fprintf_plus(stderr, "(Avahi browser) %s\n",
1134
avahi_strerror(avahi_server_errno
1135
(((mandos_context*)mc)->server)));
1136
avahi_simple_poll_quit(simple_poll);
1139
case AVAHI_BROWSER_NEW:
1140
/* We ignore the returned Avahi resolver object. In the callback
1141
function we free it. If the Avahi server is terminated before
1142
the callback function is called the Avahi server will free the
1145
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1146
interface, protocol, name, type,
1147
domain, protocol, 0,
1148
resolve_callback, mc) == NULL)
1149
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1151
avahi_strerror(avahi_server_errno
1152
(((mandos_context*)mc)->server)));
1155
case AVAHI_BROWSER_REMOVE:
1158
case AVAHI_BROWSER_ALL_FOR_NOW:
1159
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1161
fprintf_plus(stderr, "No Mandos server found, still"
1168
/* Signal handler that stops main loop after SIGTERM */
1169
static void handle_sigterm(int sig){
1174
signal_received = sig;
1175
int old_errno = errno;
1176
/* set main loop to exit */
1177
if(simple_poll != NULL){
1178
avahi_simple_poll_quit(simple_poll);
1183
__attribute__((nonnull, warn_unused_result))
1184
bool get_flags(const char *ifname, struct ifreq *ifr){
1188
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1191
perror_plus("socket");
1195
strcpy(ifr->ifr_name, ifname);
1196
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1200
perror_plus("ioctl SIOCGIFFLAGS");
1208
__attribute__((nonnull, warn_unused_result))
1209
bool good_flags(const char *ifname, const struct ifreq *ifr){
1211
/* Reject the loopback device */
1212
if(ifr->ifr_flags & IFF_LOOPBACK){
1214
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1219
/* Accept point-to-point devices only if connect_to is specified */
1220
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1222
fprintf_plus(stderr, "Accepting point-to-point interface"
1223
" \"%s\"\n", ifname);
1227
/* Otherwise, reject non-broadcast-capable devices */
1228
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1230
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1231
" \"%s\"\n", ifname);
1235
/* Reject non-ARP interfaces (including dummy interfaces) */
1236
if(ifr->ifr_flags & IFF_NOARP){
1238
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1244
/* Accept this device */
1246
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1252
* This function determines if a directory entry in /sys/class/net
1253
* corresponds to an acceptable network device.
1254
* (This function is passed to scandir(3) as a filter function.)
1256
__attribute__((nonnull, warn_unused_result))
1257
int good_interface(const struct dirent *if_entry){
1258
if(if_entry->d_name[0] == '.'){
1263
if(not get_flags(if_entry->d_name, &ifr)){
1265
fprintf_plus(stderr, "Failed to get flags for interface "
1266
"\"%s\"\n", if_entry->d_name);
1271
if(not good_flags(if_entry->d_name, &ifr)){
1278
* This function determines if a network interface is up.
1280
__attribute__((nonnull, warn_unused_result))
1281
bool interface_is_up(const char *interface){
1283
if(not get_flags(interface, &ifr)){
1285
fprintf_plus(stderr, "Failed to get flags for interface "
1286
"\"%s\"\n", interface);
1291
return (bool)(ifr.ifr_flags & IFF_UP);
1295
* This function determines if a network interface is running
1297
__attribute__((nonnull, warn_unused_result))
1298
bool interface_is_running(const char *interface){
1300
if(not get_flags(interface, &ifr)){
1302
fprintf_plus(stderr, "Failed to get flags for interface "
1303
"\"%s\"\n", interface);
1308
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1311
__attribute__((nonnull, pure, warn_unused_result))
1312
int notdotentries(const struct dirent *direntry){
1313
/* Skip "." and ".." */
1314
if(direntry->d_name[0] == '.'
1315
and (direntry->d_name[1] == '\0'
1316
or (direntry->d_name[1] == '.'
1317
and direntry->d_name[2] == '\0'))){
1323
/* Is this directory entry a runnable program? */
1324
__attribute__((nonnull, warn_unused_result))
1325
int runnable_hook(const struct dirent *direntry){
1330
if((direntry->d_name)[0] == '\0'){
1335
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1336
"abcdefghijklmnopqrstuvwxyz"
1339
if((direntry->d_name)[sret] != '\0'){
1340
/* Contains non-allowed characters */
1342
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1348
char *fullname = NULL;
1349
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1351
perror_plus("asprintf");
1355
ret = stat(fullname, &st);
1358
perror_plus("Could not stat hook");
1362
if(not (S_ISREG(st.st_mode))){
1363
/* Not a regular file */
1365
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1370
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1371
/* Not executable */
1373
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1379
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1385
__attribute__((nonnull, warn_unused_result))
1386
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1387
mandos_context *mc){
1389
struct timespec now;
1390
struct timespec waited_time;
1391
intmax_t block_time;
1394
if(mc->current_server == NULL){
1396
fprintf_plus(stderr, "Wait until first server is found."
1399
ret = avahi_simple_poll_iterate(s, -1);
1402
fprintf_plus(stderr, "Check current_server if we should run"
1405
/* the current time */
1406
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1408
perror_plus("clock_gettime");
1411
/* Calculating in ms how long time between now and server
1412
who we visted longest time ago. Now - last seen. */
1413
waited_time.tv_sec = (now.tv_sec
1414
- mc->current_server->last_seen.tv_sec);
1415
waited_time.tv_nsec = (now.tv_nsec
1416
- mc->current_server->last_seen.tv_nsec);
1417
/* total time is 10s/10,000ms.
1418
Converting to s from ms by dividing by 1,000,
1419
and ns to ms by dividing by 1,000,000. */
1420
block_time = ((retry_interval
1421
- ((intmax_t)waited_time.tv_sec * 1000))
1422
- ((intmax_t)waited_time.tv_nsec / 1000000));
1425
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1429
if(block_time <= 0){
1430
ret = start_mandos_communication(mc->current_server->ip,
1431
mc->current_server->port,
1432
mc->current_server->if_index,
1433
mc->current_server->af, mc);
1435
avahi_simple_poll_quit(s);
1438
ret = clock_gettime(CLOCK_MONOTONIC,
1439
&mc->current_server->last_seen);
1441
perror_plus("clock_gettime");
1444
mc->current_server = mc->current_server->next;
1445
block_time = 0; /* Call avahi to find new Mandos
1446
servers, but don't block */
1449
ret = avahi_simple_poll_iterate(s, (int)block_time);
1452
if(ret > 0 or errno != EINTR){
1453
return (ret != 1) ? ret : 0;
1459
/* Set effective uid to 0, return errno */
1460
__attribute__((warn_unused_result))
1461
error_t raise_privileges(void){
1462
error_t old_errno = errno;
1463
error_t ret_errno = 0;
1464
if(seteuid(0) == -1){
1466
perror_plus("seteuid");
1472
/* Set effective and real user ID to 0. Return errno. */
1473
__attribute__((warn_unused_result))
1474
error_t raise_privileges_permanently(void){
1475
error_t old_errno = errno;
1476
error_t ret_errno = raise_privileges();
1481
if(setuid(0) == -1){
1483
perror_plus("seteuid");
1489
/* Set effective user ID to unprivileged saved user ID */
1490
__attribute__((warn_unused_result))
1491
error_t lower_privileges(void){
1492
error_t old_errno = errno;
1493
error_t ret_errno = 0;
1494
if(seteuid(uid) == -1){
1496
perror_plus("seteuid");
1502
/* Lower privileges permanently */
1503
__attribute__((warn_unused_result))
1504
error_t lower_privileges_permanently(void){
1505
error_t old_errno = errno;
1506
error_t ret_errno = 0;
1507
if(setuid(uid) == -1){
1509
perror_plus("setuid");
1515
__attribute__((nonnull))
1516
void run_network_hooks(const char *mode, const char *interface,
1518
struct dirent **direntries;
1519
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1522
if(errno == ENOENT){
1524
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1525
" found\n", hookdir);
1528
perror_plus("scandir");
1531
struct dirent *direntry;
1533
int devnull = open("/dev/null", O_RDONLY);
1534
for(int i = 0; i < numhooks; i++){
1535
direntry = direntries[i];
1536
char *fullname = NULL;
1537
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1539
perror_plus("asprintf");
1543
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1546
pid_t hook_pid = fork();
1549
/* Raise privileges */
1550
if(raise_privileges_permanently() != 0){
1551
perror_plus("Failed to raise privileges");
1558
perror_plus("setgid");
1561
/* Reset supplementary groups */
1563
ret = setgroups(0, NULL);
1565
perror_plus("setgroups");
1568
ret = dup2(devnull, STDIN_FILENO);
1570
perror_plus("dup2(devnull, STDIN_FILENO)");
1573
ret = close(devnull);
1575
perror_plus("close");
1578
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1580
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1583
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1585
perror_plus("setenv");
1588
ret = setenv("DEVICE", interface, 1);
1590
perror_plus("setenv");
1593
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1595
perror_plus("setenv");
1598
ret = setenv("MODE", mode, 1);
1600
perror_plus("setenv");
1604
ret = asprintf(&delaystring, "%f", (double)delay);
1606
perror_plus("asprintf");
1609
ret = setenv("DELAY", delaystring, 1);
1612
perror_plus("setenv");
1616
if(connect_to != NULL){
1617
ret = setenv("CONNECT", connect_to, 1);
1619
perror_plus("setenv");
1623
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1624
perror_plus("execl");
1625
_exit(EXIT_FAILURE);
1629
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1630
perror_plus("waitpid");
1634
if(WIFEXITED(status)){
1635
if(WEXITSTATUS(status) != 0){
1636
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1637
" with status %d\n", direntry->d_name,
1638
WEXITSTATUS(status));
1642
} else if(WIFSIGNALED(status)){
1643
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1644
" signal %d\n", direntry->d_name,
1649
fprintf_plus(stderr, "Warning: network hook \"%s\""
1650
" crashed\n", direntry->d_name);
1657
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1665
__attribute__((nonnull, warn_unused_result))
1666
error_t bring_up_interface(const char *const interface,
1668
error_t old_errno = errno;
1670
struct ifreq network;
1671
unsigned int if_index = if_nametoindex(interface);
1673
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1683
if(not interface_is_up(interface)){
1684
error_t ret_errno = 0, ioctl_errno = 0;
1685
if(not get_flags(interface, &network)){
1687
fprintf_plus(stderr, "Failed to get flags for interface "
1688
"\"%s\"\n", interface);
1692
network.ifr_flags |= IFF_UP; /* set flag */
1694
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1697
perror_plus("socket");
1703
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1705
perror_plus("close");
1712
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1716
/* Raise privileges */
1717
ret_errno = raise_privileges();
1719
perror_plus("Failed to raise privileges");
1724
bool restore_loglevel = false;
1726
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1727
messages about the network interface to mess up the prompt */
1728
ret_linux = klogctl(8, NULL, 5);
1729
if(ret_linux == -1){
1730
perror_plus("klogctl");
1732
restore_loglevel = true;
1735
#endif /* __linux__ */
1736
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1737
ioctl_errno = errno;
1739
if(restore_loglevel){
1740
ret_linux = klogctl(7, NULL, 0);
1741
if(ret_linux == -1){
1742
perror_plus("klogctl");
1745
#endif /* __linux__ */
1747
/* If raise_privileges() succeeded above */
1749
/* Lower privileges */
1750
ret_errno = lower_privileges();
1753
perror_plus("Failed to lower privileges");
1757
/* Close the socket */
1758
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1760
perror_plus("close");
1763
if(ret_setflags == -1){
1764
errno = ioctl_errno;
1765
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1770
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1774
/* Sleep checking until interface is running.
1775
Check every 0.25s, up to total time of delay */
1776
for(int i=0; i < delay * 4; i++){
1777
if(interface_is_running(interface)){
1780
struct timespec sleeptime = { .tv_nsec = 250000000 };
1781
ret = nanosleep(&sleeptime, NULL);
1782
if(ret == -1 and errno != EINTR){
1783
perror_plus("nanosleep");
1791
__attribute__((nonnull, warn_unused_result))
1792
error_t take_down_interface(const char *const interface){
1793
error_t old_errno = errno;
1794
struct ifreq network;
1795
unsigned int if_index = if_nametoindex(interface);
1797
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1801
if(interface_is_up(interface)){
1802
error_t ret_errno = 0, ioctl_errno = 0;
1803
if(not get_flags(interface, &network) and debug){
1805
fprintf_plus(stderr, "Failed to get flags for interface "
1806
"\"%s\"\n", interface);
1810
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1812
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1815
perror_plus("socket");
1821
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1825
/* Raise privileges */
1826
ret_errno = raise_privileges();
1828
perror_plus("Failed to raise privileges");
1831
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1832
ioctl_errno = errno;
1834
/* If raise_privileges() succeeded above */
1836
/* Lower privileges */
1837
ret_errno = lower_privileges();
1840
perror_plus("Failed to lower privileges");
1844
/* Close the socket */
1845
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1847
perror_plus("close");
1850
if(ret_setflags == -1){
1851
errno = ioctl_errno;
1852
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1857
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1865
int main(int argc, char *argv[]){
1866
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1867
.priority = "SECURE256:!CTYPE-X.509:"
1868
"+CTYPE-OPENPGP", .current_server = NULL,
1869
.interfaces = NULL, .interfaces_size = 0 };
1870
AvahiSServiceBrowser *sb = NULL;
1875
int exitcode = EXIT_SUCCESS;
1876
char *interfaces_to_take_down = NULL;
1877
size_t interfaces_to_take_down_size = 0;
1878
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
1879
char old_tempdir[] = "/tmp/mandosXXXXXX";
1880
char *tempdir = NULL;
1881
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1882
const char *seckey = PATHDIR "/" SECKEY;
1883
const char *pubkey = PATHDIR "/" PUBKEY;
1884
char *interfaces_hooks = NULL;
1886
bool gnutls_initialized = false;
1887
bool gpgme_initialized = false;
1889
double retry_interval = 10; /* 10s between trying a server and
1890
retrying the same server again */
1892
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1893
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1898
/* Lower any group privileges we might have, just to be safe */
1902
perror_plus("setgid");
1905
/* Lower user privileges (temporarily) */
1909
perror_plus("seteuid");
1917
struct argp_option options[] = {
1918
{ .name = "debug", .key = 128,
1919
.doc = "Debug mode", .group = 3 },
1920
{ .name = "connect", .key = 'c',
1921
.arg = "ADDRESS:PORT",
1922
.doc = "Connect directly to a specific Mandos server",
1924
{ .name = "interface", .key = 'i',
1926
.doc = "Network interface that will be used to search for"
1929
{ .name = "seckey", .key = 's',
1931
.doc = "OpenPGP secret key file base name",
1933
{ .name = "pubkey", .key = 'p',
1935
.doc = "OpenPGP public key file base name",
1937
{ .name = "dh-bits", .key = 129,
1939
.doc = "Bit length of the prime number used in the"
1940
" Diffie-Hellman key exchange",
1942
{ .name = "priority", .key = 130,
1944
.doc = "GnuTLS priority string for the TLS handshake",
1946
{ .name = "delay", .key = 131,
1948
.doc = "Maximum delay to wait for interface startup",
1950
{ .name = "retry", .key = 132,
1952
.doc = "Retry interval used when denied by the Mandos server",
1954
{ .name = "network-hook-dir", .key = 133,
1956
.doc = "Directory where network hooks are located",
1959
* These reproduce what we would get without ARGP_NO_HELP
1961
{ .name = "help", .key = '?',
1962
.doc = "Give this help list", .group = -1 },
1963
{ .name = "usage", .key = -3,
1964
.doc = "Give a short usage message", .group = -1 },
1965
{ .name = "version", .key = 'V',
1966
.doc = "Print program version", .group = -1 },
1970
error_t parse_opt(int key, char *arg,
1971
struct argp_state *state){
1974
case 128: /* --debug */
1977
case 'c': /* --connect */
1980
case 'i': /* --interface */
1981
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
1984
argp_error(state, "%s", strerror(ret_errno));
1987
case 's': /* --seckey */
1990
case 'p': /* --pubkey */
1993
case 129: /* --dh-bits */
1995
tmpmax = strtoimax(arg, &tmp, 10);
1996
if(errno != 0 or tmp == arg or *tmp != '\0'
1997
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1998
argp_error(state, "Bad number of DH bits");
2000
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2002
case 130: /* --priority */
2005
case 131: /* --delay */
2007
delay = strtof(arg, &tmp);
2008
if(errno != 0 or tmp == arg or *tmp != '\0'){
2009
argp_error(state, "Bad delay");
2011
case 132: /* --retry */
2013
retry_interval = strtod(arg, &tmp);
2014
if(errno != 0 or tmp == arg or *tmp != '\0'
2015
or (retry_interval * 1000) > INT_MAX
2016
or retry_interval < 0){
2017
argp_error(state, "Bad retry interval");
2020
case 133: /* --network-hook-dir */
2024
* These reproduce what we would get without ARGP_NO_HELP
2026
case '?': /* --help */
2027
argp_state_help(state, state->out_stream,
2028
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2029
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2030
case -3: /* --usage */
2031
argp_state_help(state, state->out_stream,
2032
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2033
case 'V': /* --version */
2034
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2035
exit(argp_err_exit_status);
2038
return ARGP_ERR_UNKNOWN;
2043
struct argp argp = { .options = options, .parser = parse_opt,
2045
.doc = "Mandos client -- Get and decrypt"
2046
" passwords from a Mandos server" };
2047
ret = argp_parse(&argp, argc, argv,
2048
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
569
static void browse_callback(
570
AvahiSServiceBrowser *b,
571
AvahiIfIndex interface,
572
AvahiProtocol protocol,
573
AvahiBrowserEvent event,
577
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
580
AvahiServer *s = userdata;
581
assert(b); /* Spurious warning */
583
/* Called whenever a new services becomes available on the LAN or
584
is removed from the LAN */
2055
perror_plus("argp_parse");
2056
exitcode = EX_OSERR;
2059
exitcode = EX_USAGE;
2065
/* Work around Debian bug #633582:
2066
<http://bugs.debian.org/633582> */
2068
/* Re-raise privileges */
2069
ret_errno = raise_privileges();
2072
perror_plus("Failed to raise privileges");
2076
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2077
int seckey_fd = open(seckey, O_RDONLY);
2078
if(seckey_fd == -1){
2079
perror_plus("open");
2081
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2083
perror_plus("fstat");
2085
if(S_ISREG(st.st_mode)
2086
and st.st_uid == 0 and st.st_gid == 0){
2087
ret = fchown(seckey_fd, uid, gid);
2089
perror_plus("fchown");
2093
TEMP_FAILURE_RETRY(close(seckey_fd));
2097
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2098
int pubkey_fd = open(pubkey, O_RDONLY);
2099
if(pubkey_fd == -1){
2100
perror_plus("open");
2102
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2104
perror_plus("fstat");
2106
if(S_ISREG(st.st_mode)
2107
and st.st_uid == 0 and st.st_gid == 0){
2108
ret = fchown(pubkey_fd, uid, gid);
2110
perror_plus("fchown");
2114
TEMP_FAILURE_RETRY(close(pubkey_fd));
2118
/* Lower privileges */
2119
ret_errno = lower_privileges();
2122
perror_plus("Failed to lower privileges");
2127
/* Remove invalid interface names (except "none") */
2129
char *interface = NULL;
2130
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2132
if(strcmp(interface, "none") != 0
2133
and if_nametoindex(interface) == 0){
2134
if(interface[0] != '\0'){
2135
fprintf_plus(stderr, "Not using nonexisting interface"
2136
" \"%s\"\n", interface);
2138
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2144
/* Run network hooks */
2146
if(mc.interfaces != NULL){
2147
interfaces_hooks = malloc(mc.interfaces_size);
2148
if(interfaces_hooks == NULL){
2149
perror_plus("malloc");
2152
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2153
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2155
run_network_hooks("start", interfaces_hooks != NULL ?
2156
interfaces_hooks : "", delay);
2160
avahi_set_log_function(empty_log);
2163
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2164
from the signal handler */
2165
/* Initialize the pseudo-RNG for Avahi */
2166
srand((unsigned int) time(NULL));
2167
simple_poll = avahi_simple_poll_new();
2168
if(simple_poll == NULL){
2169
fprintf_plus(stderr,
2170
"Avahi: Failed to create simple poll object.\n");
2171
exitcode = EX_UNAVAILABLE;
2175
sigemptyset(&sigterm_action.sa_mask);
2176
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2178
perror_plus("sigaddset");
2179
exitcode = EX_OSERR;
2182
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2184
perror_plus("sigaddset");
2185
exitcode = EX_OSERR;
2188
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2190
perror_plus("sigaddset");
2191
exitcode = EX_OSERR;
2194
/* Need to check if the handler is SIG_IGN before handling:
2195
| [[info:libc:Initial Signal Actions]] |
2196
| [[info:libc:Basic Signal Handling]] |
2198
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2200
perror_plus("sigaction");
2203
if(old_sigterm_action.sa_handler != SIG_IGN){
2204
ret = sigaction(SIGINT, &sigterm_action, NULL);
2206
perror_plus("sigaction");
2207
exitcode = EX_OSERR;
2211
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2213
perror_plus("sigaction");
2216
if(old_sigterm_action.sa_handler != SIG_IGN){
2217
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2219
perror_plus("sigaction");
2220
exitcode = EX_OSERR;
2224
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2226
perror_plus("sigaction");
2229
if(old_sigterm_action.sa_handler != SIG_IGN){
2230
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2232
perror_plus("sigaction");
2233
exitcode = EX_OSERR;
2238
/* If no interfaces were specified, make a list */
2239
if(mc.interfaces == NULL){
2240
struct dirent **direntries;
2241
/* Look for any good interfaces */
2242
ret = scandir(sys_class_net, &direntries, good_interface,
2245
/* Add all found interfaces to interfaces list */
2246
for(int i = 0; i < ret; ++i){
2247
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2248
direntries[i]->d_name);
2251
perror_plus("argz_add");
2255
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2256
direntries[i]->d_name);
2262
fprintf_plus(stderr, "Could not find a network interface\n");
2263
exitcode = EXIT_FAILURE;
2268
/* Bring up interfaces which are down, and remove any "none"s */
2270
char *interface = NULL;
2271
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2273
/* If interface name is "none", stop bringing up interfaces.
2274
Also remove all instances of "none" from the list */
2275
if(strcmp(interface, "none") == 0){
2276
argz_delete(&mc.interfaces, &mc.interfaces_size,
2279
while((interface = argz_next(mc.interfaces,
2280
mc.interfaces_size, interface))){
2281
if(strcmp(interface, "none") == 0){
2282
argz_delete(&mc.interfaces, &mc.interfaces_size,
2289
bool interface_was_up = interface_is_up(interface);
2290
errno = bring_up_interface(interface, delay);
2291
if(not interface_was_up){
2293
perror_plus("Failed to bring up interface");
2295
errno = argz_add(&interfaces_to_take_down,
2296
&interfaces_to_take_down_size,
2299
perror_plus("argz_add");
2304
if(debug and (interfaces_to_take_down == NULL)){
2305
fprintf_plus(stderr, "No interfaces were brought up\n");
2309
/* If we only got one interface, explicitly use only that one */
2310
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2312
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2315
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2322
ret = init_gnutls_global(pubkey, seckey, &mc);
2324
fprintf_plus(stderr, "init_gnutls_global failed\n");
2325
exitcode = EX_UNAVAILABLE;
2328
gnutls_initialized = true;
2335
/* Try /run/tmp before /tmp */
2336
tempdir = mkdtemp(run_tempdir);
2337
if(tempdir == NULL and errno == ENOENT){
2339
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2340
run_tempdir, old_tempdir);
2342
tempdir = mkdtemp(old_tempdir);
2344
if(tempdir == NULL){
2345
perror_plus("mkdtemp");
2353
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2354
fprintf_plus(stderr, "init_gpgme failed\n");
2355
exitcode = EX_UNAVAILABLE;
2358
gpgme_initialized = true;
2365
if(connect_to != NULL){
2366
/* Connect directly, do not use Zeroconf */
2367
/* (Mainly meant for debugging) */
2368
char *address = strrchr(connect_to, ':');
2370
if(address == NULL){
2371
fprintf_plus(stderr, "No colon in address\n");
2372
exitcode = EX_USAGE;
2382
tmpmax = strtoimax(address+1, &tmp, 10);
2383
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2384
or tmpmax != (in_port_t)tmpmax){
2385
fprintf_plus(stderr, "Bad port number\n");
2386
exitcode = EX_USAGE;
2394
port = (in_port_t)tmpmax;
2396
/* Colon in address indicates IPv6 */
2398
if(strchr(connect_to, ':') != NULL){
2400
/* Accept [] around IPv6 address - see RFC 5952 */
2401
if(connect_to[0] == '[' and address[-1] == ']')
2409
address = connect_to;
2415
while(not quit_now){
2416
ret = start_mandos_communication(address, port, if_index, af,
2418
if(quit_now or ret == 0){
2422
fprintf_plus(stderr, "Retrying in %d seconds\n",
2423
(int)retry_interval);
2425
sleep((unsigned int)retry_interval);
2429
exitcode = EXIT_SUCCESS;
588
case AVAHI_BROWSER_FAILURE:
590
fprintf(stderr, "(Browser) %s\n",
591
avahi_strerror(avahi_server_errno(server)));
592
avahi_simple_poll_quit(simple_poll);
595
case AVAHI_BROWSER_NEW:
596
/* We ignore the returned resolver object. In the callback
597
function we free it. If the server is terminated before
598
the callback function is called the server will free
599
the resolver for us. */
601
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
603
AVAHI_PROTO_INET6, 0,
604
resolve_callback, s)))
605
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
606
avahi_strerror(avahi_server_errno(s)));
609
case AVAHI_BROWSER_REMOVE:
612
case AVAHI_BROWSER_ALL_FOR_NOW:
613
case AVAHI_BROWSER_CACHE_EXHAUSTED:
618
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
2440
619
AvahiServerConfig config;
2441
/* Do not publish any local Zeroconf records */
620
AvahiSServiceBrowser *sb = NULL;
623
int returncode = EXIT_SUCCESS;
624
const char *interface = "eth0";
627
static struct option long_options[] = {
628
{"debug", no_argument, (int *)&debug, 1},
629
{"interface", required_argument, 0, 'i'},
632
int option_index = 0;
633
ret = getopt_long (argc, argv, "i:", long_options,
652
avahi_set_log_function(empty_log);
655
/* Initialize the psuedo-RNG */
656
srand((unsigned int) time(NULL));
658
/* Allocate main loop object */
659
if (!(simple_poll = avahi_simple_poll_new())) {
660
fprintf(stderr, "Failed to create simple poll object.\n");
665
/* Do not publish any local records */
2442
666
avahi_server_config_init(&config);
2443
667
config.publish_hinfo = 0;
2444
668
config.publish_addresses = 0;
2445
669
config.publish_workstation = 0;
2446
670
config.publish_domain = 0;
2448
672
/* Allocate a new server */
2449
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2450
&config, NULL, NULL, &ret_errno);
2452
/* Free the Avahi configuration data */
673
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
674
&config, NULL, NULL, &error);
676
/* Free the configuration data */
2453
677
avahi_server_config_free(&config);
2456
/* Check if creating the Avahi server object succeeded */
2457
if(mc.server == NULL){
2458
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2459
avahi_strerror(ret_errno));
2460
exitcode = EX_UNAVAILABLE;
2468
/* Create the Avahi service browser */
2469
sb = avahi_s_service_browser_new(mc.server, if_index,
2470
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2471
NULL, 0, browse_callback,
2474
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2475
avahi_strerror(avahi_server_errno(mc.server)));
2476
exitcode = EX_UNAVAILABLE;
2484
/* Run the main loop */
2487
fprintf_plus(stderr, "Starting Avahi loop search\n");
2490
ret = avahi_loop_with_timeout(simple_poll,
2491
(int)(retry_interval * 1000), &mc);
2493
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2494
(ret == 0) ? "successfully" : "with error");
2500
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2503
/* Cleanup things */
2504
free(mc.interfaces);
2507
avahi_s_service_browser_free(sb);
2509
if(mc.server != NULL)
2510
avahi_server_free(mc.server);
2512
if(simple_poll != NULL)
2513
avahi_simple_poll_free(simple_poll);
2515
if(gnutls_initialized){
2516
gnutls_certificate_free_credentials(mc.cred);
2517
gnutls_global_deinit();
2518
gnutls_dh_params_deinit(mc.dh_params);
2521
if(gpgme_initialized){
2522
gpgme_release(mc.ctx);
2525
/* Cleans up the circular linked list of Mandos servers the client
2527
if(mc.current_server != NULL){
2528
mc.current_server->prev->next = NULL;
2529
while(mc.current_server != NULL){
2530
server *next = mc.current_server->next;
2531
free(mc.current_server);
2532
mc.current_server = next;
2536
/* Re-raise privileges */
2538
ret_errno = raise_privileges();
2540
perror_plus("Failed to raise privileges");
2543
/* Run network hooks */
2544
run_network_hooks("stop", interfaces_hooks != NULL ?
2545
interfaces_hooks : "", delay);
2547
/* Take down the network interfaces which were brought up */
2549
char *interface = NULL;
2550
while((interface=argz_next(interfaces_to_take_down,
2551
interfaces_to_take_down_size,
2553
ret_errno = take_down_interface(interface);
2556
perror_plus("Failed to take down interface");
2559
if(debug and (interfaces_to_take_down == NULL)){
2560
fprintf_plus(stderr, "No interfaces needed to be taken"
2566
ret_errno = lower_privileges_permanently();
2568
perror_plus("Failed to lower privileges permanently");
2572
free(interfaces_to_take_down);
2573
free(interfaces_hooks);
2575
/* Removes the GPGME temp directory and all files inside */
2576
if(tempdir != NULL){
2577
struct dirent **direntries = NULL;
2578
struct dirent *direntry = NULL;
2579
int numentries = scandir(tempdir, &direntries, notdotentries,
2582
for(int i = 0; i < numentries; i++){
2583
direntry = direntries[i];
2584
char *fullname = NULL;
2585
ret = asprintf(&fullname, "%s/%s", tempdir,
2588
perror_plus("asprintf");
2591
ret = remove(fullname);
2593
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2600
/* need to clean even if 0 because man page doesn't specify */
2602
if(numentries == -1){
2603
perror_plus("scandir");
2605
ret = rmdir(tempdir);
2606
if(ret == -1 and errno != ENOENT){
2607
perror_plus("rmdir");
2612
sigemptyset(&old_sigterm_action.sa_mask);
2613
old_sigterm_action.sa_handler = SIG_DFL;
2614
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2615
&old_sigterm_action,
2618
perror_plus("sigaction");
2621
ret = raise(signal_received);
2622
} while(ret != 0 and errno == EINTR);
2624
perror_plus("raise");
2627
TEMP_FAILURE_RETRY(pause());
679
/* Check if creating the server object succeeded */
681
fprintf(stderr, "Failed to create server: %s\n",
682
avahi_strerror(error));
683
returncode = EXIT_FAILURE;
687
/* Create the service browser */
688
sb = avahi_s_service_browser_new(server,
690
if_nametoindex(interface),
692
"_mandos._tcp", NULL, 0,
693
browse_callback, server);
695
fprintf(stderr, "Failed to create service browser: %s\n",
696
avahi_strerror(avahi_server_errno(server)));
697
returncode = EXIT_FAILURE;
701
/* Run the main loop */
704
fprintf(stderr, "Starting avahi loop search\n");
707
avahi_simple_poll_loop(simple_poll);
712
fprintf(stderr, "%s exiting\n", argv[0]);
717
avahi_s_service_browser_free(sb);
720
avahi_server_free(server);
723
avahi_simple_poll_free(simple_poll);