33
110
#include <avahi-common/malloc.h>
34
111
#include <avahi-common/error.h>
37
#include <sys/types.h> /* socket(), setsockopt(), inet_pton() */
38
#include <sys/socket.h> /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */
39
#include <gnutls/gnutls.h> /* ALL GNUTLS STUFF */
40
#include <gnutls/openpgp.h> /* gnutls with openpgp stuff */
42
#include <unistd.h> /* close() */
43
#include <netinet/in.h>
44
#include <stdbool.h> /* true */
45
#include <string.h> /* memset */
46
#include <arpa/inet.h> /* inet_pton() */
47
#include <iso646.h> /* not */
50
#include <errno.h> /* perror() */
55
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
57
#define CERTFILE CERT_ROOT "openpgp-client.txt"
58
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
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,
59
130
#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"
62
137
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 */
65
gnutls_session_t session;
66
161
gnutls_certificate_credentials_t cred;
162
unsigned int dh_bits;
67
163
gnutls_dh_params_t dh_params;
71
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
72
gpgme_data_t dh_crypto, dh_plain;
164
const char *priority;
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,
76
size_t new_packet_capacity = 0;
77
size_t new_packet_length = 0;
78
266
gpgme_engine_info_t engine_info;
81
fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
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");
85
309
gpgme_check_version(NULL);
86
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
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));
88
/* Set GPGME home directory */
89
rc = gpgme_get_engine_info (&engine_info);
90
if (rc != GPG_ERR_NO_ERROR){
91
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
92
gpgme_strsource(rc), gpgme_strerror(rc));
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));
95
324
while(engine_info != NULL){
96
325
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
97
326
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
98
engine_info->file_name, homedir);
327
engine_info->file_name, tempdir);
101
330
engine_info = engine_info->next;
103
332
if(engine_info == NULL){
104
fprintf(stderr, "Could not set home dir to %s\n", homedir);
108
/* Create new GPGME data buffer from packet buffer */
109
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
110
if (rc != GPG_ERR_NO_ERROR){
111
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
112
gpgme_strsource(rc), gpgme_strerror(rc));
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));
116
382
/* Create new empty GPGME data buffer for the plaintext */
117
383
rc = gpgme_data_new(&dh_plain);
118
if (rc != GPG_ERR_NO_ERROR){
119
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
120
gpgme_strsource(rc), gpgme_strerror(rc));
124
/* Create new GPGME "context" */
125
rc = gpgme_new(&ctx);
126
if (rc != GPG_ERR_NO_ERROR){
127
fprintf(stderr, "bad gpgme_new: %s: %s\n",
128
gpgme_strsource(rc), gpgme_strerror(rc));
132
/* Decrypt data from the FILE pointer to the plaintext data buffer */
133
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
134
if (rc != GPG_ERR_NO_ERROR){
135
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
136
gpgme_strsource(rc), gpgme_strerror(rc));
141
fprintf(stderr, "decryption of gpg packet succeeded\n");
145
gpgme_decrypt_result_t result;
146
result = gpgme_op_decrypt_result(ctx);
148
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
150
fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);
151
fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);
152
if(result->file_name != NULL){
153
fprintf(stderr, "File name: %s\n", result->file_name);
155
gpgme_recipient_t recipient;
156
recipient = result->recipients;
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;
158
414
while(recipient != NULL){
159
fprintf(stderr, "Public key algorithm: %s\n",
160
gpgme_pubkey_algo_name(recipient->pubkey_algo));
161
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
162
fprintf(stderr, "Secret key available: %s\n",
163
recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
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
164
422
recipient = recipient->next;
170
/* Delete the GPGME FILE pointer cryptotext data buffer */
171
gpgme_data_release(dh_crypto);
430
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
173
433
/* Seek back to the beginning of the GPGME plaintext data buffer */
174
gpgme_data_seek(dh_plain, 0, SEEK_SET);
434
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
435
perror_plus("gpgme_data_seek");
436
plaintext_length = -1;
178
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
179
*new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
180
if (*new_packet == NULL){
184
new_packet_capacity += BUFFER_SIZE;
442
plaintext_capacity = incbuffer(plaintext,
443
(size_t)plaintext_length,
445
if(plaintext_capacity == 0){
446
perror_plus("incbuffer");
447
plaintext_length = -1;
187
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
451
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
188
453
/* Print the data, if any */
190
/* If password is empty, then a incorrect error will be printed */
194
perror("gpgme_data_read");
459
perror_plus("gpgme_data_read");
460
plaintext_length = -1;
197
new_packet_length += ret;
463
plaintext_length += ret;
201
fprintf(stderr, "decrypted password is: %s\n", *new_packet);
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");
204
/* Delete the GPGME plaintext data buffer */
476
/* Delete the GPGME cryptotext data buffer */
477
gpgme_data_release(dh_crypto);
479
/* Delete the GPGME plaintext data buffer */
205
480
gpgme_data_release(dh_plain);
206
return new_packet_length;
481
return plaintext_length;
209
static const char * safer_gnutls_strerror (int value) {
210
const char *ret = gnutls_strerror (value);
484
__attribute__((warn_unused_result))
485
static const char *safer_gnutls_strerror(int value){
486
const char *ret = gnutls_strerror(value);
212
488
ret = "(unknown)";
216
void debuggnutls(int level, const char* string){
217
fprintf(stderr, "%s", string);
492
/* GnuTLS log function callback */
493
__attribute__((nonnull))
494
static void debuggnutls(__attribute__((unused)) int level,
496
fprintf_plus(stderr, "GnuTLS: %s", string);
220
int initgnutls(encrypted_session *es){
499
__attribute__((nonnull, warn_unused_result))
500
static int init_gnutls_global(const char *pubkeyfilename,
501
const char *seckeyfilename,
225
fprintf(stderr, "Initializing gnutls\n");
506
fprintf_plus(stderr, "Initializing GnuTLS\n");
229
if ((ret = gnutls_global_init ())
230
!= GNUTLS_E_SUCCESS) {
231
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
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));
517
/* "Use a log level over 10 to enable all debugging options."
236
520
gnutls_global_set_log_level(11);
237
521
gnutls_global_set_log_function(debuggnutls);
241
/* openpgp credentials */
242
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
243
!= GNUTLS_E_SUCCESS) {
244
fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
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();
249
fprintf(stderr, "Attempting to use openpgp certificate %s"
250
" and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
534
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
535
" secret key %s as GnuTLS credentials\n",
253
540
ret = gnutls_certificate_set_openpgp_key_file
254
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
255
if (ret != GNUTLS_E_SUCCESS) {
257
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
258
ret, CERTFILE, KEYFILE);
259
fprintf(stdout, "The Error is: %s\n",
260
safer_gnutls_strerror(ret));
264
//Gnutls server initialization
265
if ((ret = gnutls_dh_params_init (&es->dh_params))
266
!= GNUTLS_E_SUCCESS) {
267
fprintf (stderr, "Error in dh parameter initialization: %s\n",
268
safer_gnutls_strerror(ret));
272
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
273
!= GNUTLS_E_SUCCESS) {
274
fprintf (stderr, "Error in prime generation: %s\n",
275
safer_gnutls_strerror(ret));
279
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
281
// Gnutls session creation
282
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
283
!= GNUTLS_E_SUCCESS){
284
fprintf(stderr, "Error in gnutls session initialization: %s\n",
285
safer_gnutls_strerror(ret));
288
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
289
!= GNUTLS_E_SUCCESS) {
290
fprintf(stderr, "Syntax error at: %s\n", err);
291
fprintf(stderr, "Gnutls error: %s\n",
292
safer_gnutls_strerror(ret));
296
if ((ret = gnutls_credentials_set
297
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
298
!= GNUTLS_E_SUCCESS) {
299
fprintf(stderr, "Error setting a credentials set: %s\n",
300
safer_gnutls_strerror(ret));
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);
304
629
/* ignore client certificate if any. */
305
gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
630
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
307
gnutls_dh_set_prime_bits (es->session, DH_BITS);
632
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
312
void empty_log(AvahiLogLevel level, const char *txt){}
637
/* Avahi log function callback */
638
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
639
__attribute__((unused)) const char *txt){}
314
int start_mandos_communication(char *ip, uint16_t port){
316
struct sockaddr_in6 to;
317
encrypted_session es;
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;
318
649
char *buffer = NULL;
319
char *decrypted_buffer;
650
char *decrypted_buffer = NULL;
320
651
size_t buffer_length = 0;
321
652
size_t buffer_capacity = 0;
322
ssize_t decrypted_buffer_size;
324
const char interface[] = "eth0";
327
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
330
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
337
fprintf(stderr, "Binding to interface %s\n", interface);
340
ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
342
perror("setsockopt bindtodevice");
346
memset(&to,0,sizeof(to));
347
to.sin6_family = AF_INET6;
348
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
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");
354
fprintf(stderr, "Bad address: %s\n", ip);
357
to.sin6_port = htons(port);
358
to.sin6_scope_id = if_nametoindex(interface);
361
fprintf(stderr, "Connection to: %s\n", ip);
364
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
370
ret = initgnutls (&es);
377
gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
380
fprintf(stderr, "Establishing tls session with %s\n", ip);
384
ret = gnutls_handshake (es.session);
386
if (ret != GNUTLS_E_SUCCESS){
387
fprintf(stderr, "\n*** Handshake failed ***\n");
393
//Retrieve gpg packet that contains the wanted password
396
fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
400
if (buffer_length + BUFFER_SIZE > buffer_capacity){
401
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
406
buffer_capacity += BUFFER_SIZE;
409
ret = gnutls_record_recv
410
(es.session, buffer+buffer_length, BUFFER_SIZE);
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){
896
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
903
/* Read OpenPGP packet that contains the wanted password */
906
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
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,
416
938
case GNUTLS_E_INTERRUPTED:
417
939
case GNUTLS_E_AGAIN:
419
941
case GNUTLS_E_REHANDSHAKE:
420
ret = gnutls_handshake (es.session);
422
fprintf(stderr, "\n*** Handshake failed ***\n");
943
ret = gnutls_handshake(session);
949
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
951
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
429
fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
431
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
435
buffer_length += ret;
439
if (buffer_length > 0){
440
if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
441
fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
442
free(decrypted_buffer);
959
fprintf_plus(stderr, "Unknown error while reading data from"
960
" encrypted session with Mandos server\n");
961
gnutls_bye(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,
1003
if(ret == 0 and ferror(stdout)){
1006
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1012
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);
451
fprintf(stderr, "Closing tls session\n");
455
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
458
gnutls_deinit (es.session);
459
gnutls_certificate_free_credentials (es.cred);
460
gnutls_global_deinit ();
464
static AvahiSimplePoll *simple_poll = NULL;
465
static AvahiServer *server = NULL;
467
static void resolve_callback(
468
AvahiSServiceResolver *r,
469
AVAHI_GCC_UNUSED AvahiIfIndex interface,
470
AVAHI_GCC_UNUSED AvahiProtocol protocol,
471
AvahiResolverEvent event,
475
const char *host_name,
476
const AvahiAddress *address,
478
AvahiStringList *txt,
479
AvahiLookupResultFlags flags,
480
AVAHI_GCC_UNUSED void* userdata) {
484
/* Called whenever a service has been resolved successfully or timed out */
487
case AVAHI_RESOLVER_FAILURE:
488
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));
491
case AVAHI_RESOLVER_FOUND: {
492
char ip[AVAHI_ADDRESS_STR_MAX];
493
avahi_address_snprint(ip, sizeof(ip), address);
495
fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
497
int ret = start_mandos_communication(ip, port);
505
avahi_s_service_resolver_free(r);
508
static void browse_callback(
509
AvahiSServiceBrowser *b,
510
AvahiIfIndex interface,
511
AvahiProtocol protocol,
512
AvahiBrowserEvent event,
516
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
519
AvahiServer *s = userdata;
522
/* Called whenever a new services becomes available on the LAN or is removed from the LAN */
526
case AVAHI_BROWSER_FAILURE:
528
fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
529
avahi_simple_poll_quit(simple_poll);
532
case AVAHI_BROWSER_NEW:
533
/* We ignore the returned resolver object. In the callback
534
function we free it. If the server is terminated before
535
the callback function is called the server will free
536
the resolver for us. */
538
if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
539
fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
543
case AVAHI_BROWSER_REMOVE:
546
case AVAHI_BROWSER_ALL_FOR_NOW:
547
case AVAHI_BROWSER_CACHE_EXHAUSTED:
552
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
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
1063
/* Called whenever a service has been resolved successfully or
1072
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)));
1080
case AVAHI_RESOLVER_FOUND:
1082
char ip[AVAHI_ADDRESS_STR_MAX];
1083
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);
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"
1105
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();
1718
bool restore_loglevel = false;
1720
perror_plus("Failed to raise privileges");
1725
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1726
messages about the network interface to mess up the prompt */
1727
ret_linux = klogctl(8, NULL, 5);
1728
if(ret_linux == -1){
1729
perror_plus("klogctl");
1731
restore_loglevel = true;
1734
#endif /* __linux__ */
1735
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1736
ioctl_errno = errno;
1738
if(restore_loglevel){
1739
ret_linux = klogctl(7, NULL, 0);
1740
if(ret_linux == -1){
1741
perror_plus("klogctl");
1744
#endif /* __linux__ */
1746
/* If raise_privileges() succeeded above */
1748
/* Lower privileges */
1749
ret_errno = lower_privileges();
1752
perror_plus("Failed to lower privileges");
1756
/* Close the socket */
1757
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1759
perror_plus("close");
1762
if(ret_setflags == -1){
1763
errno = ioctl_errno;
1764
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1769
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1773
/* Sleep checking until interface is running.
1774
Check every 0.25s, up to total time of delay */
1775
for(int i=0; i < delay * 4; i++){
1776
if(interface_is_running(interface)){
1779
struct timespec sleeptime = { .tv_nsec = 250000000 };
1780
ret = nanosleep(&sleeptime, NULL);
1781
if(ret == -1 and errno != EINTR){
1782
perror_plus("nanosleep");
1790
__attribute__((nonnull, warn_unused_result))
1791
error_t take_down_interface(const char *const interface){
1792
error_t old_errno = errno;
1793
struct ifreq network;
1794
unsigned int if_index = if_nametoindex(interface);
1796
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1800
if(interface_is_up(interface)){
1801
error_t ret_errno = 0, ioctl_errno = 0;
1802
if(not get_flags(interface, &network) and debug){
1804
fprintf_plus(stderr, "Failed to get flags for interface "
1805
"\"%s\"\n", interface);
1809
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1811
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1814
perror_plus("socket");
1820
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1824
/* Raise privileges */
1825
ret_errno = raise_privileges();
1827
perror_plus("Failed to raise privileges");
1829
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1830
ioctl_errno = errno;
1832
/* If raise_privileges() succeeded above */
1834
/* Lower privileges */
1835
ret_errno = lower_privileges();
1838
perror_plus("Failed to lower privileges");
1842
/* Close the socket */
1843
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1845
perror_plus("close");
1848
if(ret_setflags == -1){
1849
errno = ioctl_errno;
1850
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1855
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1863
int main(int argc, char *argv[]){
1864
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1865
.priority = "SECURE256:!CTYPE-X.509:"
1866
"+CTYPE-OPENPGP", .current_server = NULL,
1867
.interfaces = NULL, .interfaces_size = 0 };
1868
AvahiSServiceBrowser *sb = NULL;
1873
int exitcode = EXIT_SUCCESS;
1874
char *interfaces_to_take_down = NULL;
1875
size_t interfaces_to_take_down_size = 0;
1876
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
1877
char old_tempdir[] = "/tmp/mandosXXXXXX";
1878
char *tempdir = NULL;
1879
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1880
const char *seckey = PATHDIR "/" SECKEY;
1881
const char *pubkey = PATHDIR "/" PUBKEY;
1882
char *interfaces_hooks = NULL;
1884
bool gnutls_initialized = false;
1885
bool gpgme_initialized = false;
1887
double retry_interval = 10; /* 10s between trying a server and
1888
retrying the same server again */
1890
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1891
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1896
/* Lower any group privileges we might have, just to be safe */
1900
perror_plus("setgid");
1903
/* Lower user privileges (temporarily) */
1907
perror_plus("seteuid");
1915
struct argp_option options[] = {
1916
{ .name = "debug", .key = 128,
1917
.doc = "Debug mode", .group = 3 },
1918
{ .name = "connect", .key = 'c',
1919
.arg = "ADDRESS:PORT",
1920
.doc = "Connect directly to a specific Mandos server",
1922
{ .name = "interface", .key = 'i',
1924
.doc = "Network interface that will be used to search for"
1927
{ .name = "seckey", .key = 's',
1929
.doc = "OpenPGP secret key file base name",
1931
{ .name = "pubkey", .key = 'p',
1933
.doc = "OpenPGP public key file base name",
1935
{ .name = "dh-bits", .key = 129,
1937
.doc = "Bit length of the prime number used in the"
1938
" Diffie-Hellman key exchange",
1940
{ .name = "priority", .key = 130,
1942
.doc = "GnuTLS priority string for the TLS handshake",
1944
{ .name = "delay", .key = 131,
1946
.doc = "Maximum delay to wait for interface startup",
1948
{ .name = "retry", .key = 132,
1950
.doc = "Retry interval used when denied by the Mandos server",
1952
{ .name = "network-hook-dir", .key = 133,
1954
.doc = "Directory where network hooks are located",
1957
* These reproduce what we would get without ARGP_NO_HELP
1959
{ .name = "help", .key = '?',
1960
.doc = "Give this help list", .group = -1 },
1961
{ .name = "usage", .key = -3,
1962
.doc = "Give a short usage message", .group = -1 },
1963
{ .name = "version", .key = 'V',
1964
.doc = "Print program version", .group = -1 },
1968
error_t parse_opt(int key, char *arg,
1969
struct argp_state *state){
1972
case 128: /* --debug */
1975
case 'c': /* --connect */
1978
case 'i': /* --interface */
1979
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
1982
argp_error(state, "%s", strerror(ret_errno));
1985
case 's': /* --seckey */
1988
case 'p': /* --pubkey */
1991
case 129: /* --dh-bits */
1993
tmpmax = strtoimax(arg, &tmp, 10);
1994
if(errno != 0 or tmp == arg or *tmp != '\0'
1995
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1996
argp_error(state, "Bad number of DH bits");
1998
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2000
case 130: /* --priority */
2003
case 131: /* --delay */
2005
delay = strtof(arg, &tmp);
2006
if(errno != 0 or tmp == arg or *tmp != '\0'){
2007
argp_error(state, "Bad delay");
2009
case 132: /* --retry */
2011
retry_interval = strtod(arg, &tmp);
2012
if(errno != 0 or tmp == arg or *tmp != '\0'
2013
or (retry_interval * 1000) > INT_MAX
2014
or retry_interval < 0){
2015
argp_error(state, "Bad retry interval");
2018
case 133: /* --network-hook-dir */
2022
* These reproduce what we would get without ARGP_NO_HELP
2024
case '?': /* --help */
2025
argp_state_help(state, state->out_stream,
2026
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2027
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2028
case -3: /* --usage */
2029
argp_state_help(state, state->out_stream,
2030
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2031
case 'V': /* --version */
2032
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2033
exit(argp_err_exit_status);
2036
return ARGP_ERR_UNKNOWN;
2041
struct argp argp = { .options = options, .parser = parse_opt,
2043
.doc = "Mandos client -- Get and decrypt"
2044
" passwords from a Mandos server" };
2045
ret = argp_parse(&argp, argc, argv,
2046
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2053
perror_plus("argp_parse");
2054
exitcode = EX_OSERR;
2057
exitcode = EX_USAGE;
2063
/* Work around Debian bug #633582:
2064
<http://bugs.debian.org/633582> */
2066
/* Re-raise privileges */
2067
ret_errno = raise_privileges();
2070
perror_plus("Failed to raise privileges");
2074
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2075
int seckey_fd = open(seckey, O_RDONLY);
2076
if(seckey_fd == -1){
2077
perror_plus("open");
2079
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2081
perror_plus("fstat");
2083
if(S_ISREG(st.st_mode)
2084
and st.st_uid == 0 and st.st_gid == 0){
2085
ret = fchown(seckey_fd, uid, gid);
2087
perror_plus("fchown");
2091
TEMP_FAILURE_RETRY(close(seckey_fd));
2095
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2096
int pubkey_fd = open(pubkey, O_RDONLY);
2097
if(pubkey_fd == -1){
2098
perror_plus("open");
2100
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2102
perror_plus("fstat");
2104
if(S_ISREG(st.st_mode)
2105
and st.st_uid == 0 and st.st_gid == 0){
2106
ret = fchown(pubkey_fd, uid, gid);
2108
perror_plus("fchown");
2112
TEMP_FAILURE_RETRY(close(pubkey_fd));
2116
/* Lower privileges */
2117
ret_errno = lower_privileges();
2120
perror_plus("Failed to lower privileges");
2125
/* Remove invalid interface names (except "none") */
2127
char *interface = NULL;
2128
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2130
if(strcmp(interface, "none") != 0
2131
and if_nametoindex(interface) == 0){
2132
if(interface[0] != '\0'){
2133
fprintf_plus(stderr, "Not using nonexisting interface"
2134
" \"%s\"\n", interface);
2136
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2142
/* Run network hooks */
2144
if(mc.interfaces != NULL){
2145
interfaces_hooks = malloc(mc.interfaces_size);
2146
if(interfaces_hooks == NULL){
2147
perror_plus("malloc");
2150
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2151
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2153
run_network_hooks("start", interfaces_hooks != NULL ?
2154
interfaces_hooks : "", delay);
2158
avahi_set_log_function(empty_log);
2161
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2162
from the signal handler */
2163
/* Initialize the pseudo-RNG for Avahi */
2164
srand((unsigned int) time(NULL));
2165
simple_poll = avahi_simple_poll_new();
2166
if(simple_poll == NULL){
2167
fprintf_plus(stderr,
2168
"Avahi: Failed to create simple poll object.\n");
2169
exitcode = EX_UNAVAILABLE;
2173
sigemptyset(&sigterm_action.sa_mask);
2174
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2176
perror_plus("sigaddset");
2177
exitcode = EX_OSERR;
2180
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2182
perror_plus("sigaddset");
2183
exitcode = EX_OSERR;
2186
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2188
perror_plus("sigaddset");
2189
exitcode = EX_OSERR;
2192
/* Need to check if the handler is SIG_IGN before handling:
2193
| [[info:libc:Initial Signal Actions]] |
2194
| [[info:libc:Basic Signal Handling]] |
2196
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2198
perror_plus("sigaction");
2201
if(old_sigterm_action.sa_handler != SIG_IGN){
2202
ret = sigaction(SIGINT, &sigterm_action, NULL);
2204
perror_plus("sigaction");
2205
exitcode = EX_OSERR;
2209
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2211
perror_plus("sigaction");
2214
if(old_sigterm_action.sa_handler != SIG_IGN){
2215
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2217
perror_plus("sigaction");
2218
exitcode = EX_OSERR;
2222
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2224
perror_plus("sigaction");
2227
if(old_sigterm_action.sa_handler != SIG_IGN){
2228
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2230
perror_plus("sigaction");
2231
exitcode = EX_OSERR;
2236
/* If no interfaces were specified, make a list */
2237
if(mc.interfaces == NULL){
2238
struct dirent **direntries;
2239
/* Look for any good interfaces */
2240
ret = scandir(sys_class_net, &direntries, good_interface,
2243
/* Add all found interfaces to interfaces list */
2244
for(int i = 0; i < ret; ++i){
2245
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2246
direntries[i]->d_name);
2249
perror_plus("argz_add");
2253
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2254
direntries[i]->d_name);
2260
fprintf_plus(stderr, "Could not find a network interface\n");
2261
exitcode = EXIT_FAILURE;
2266
/* Bring up interfaces which are down, and remove any "none"s */
2268
char *interface = NULL;
2269
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2271
/* If interface name is "none", stop bringing up interfaces.
2272
Also remove all instances of "none" from the list */
2273
if(strcmp(interface, "none") == 0){
2274
argz_delete(&mc.interfaces, &mc.interfaces_size,
2277
while((interface = argz_next(mc.interfaces,
2278
mc.interfaces_size, interface))){
2279
if(strcmp(interface, "none") == 0){
2280
argz_delete(&mc.interfaces, &mc.interfaces_size,
2287
bool interface_was_up = interface_is_up(interface);
2288
errno = bring_up_interface(interface, delay);
2289
if(not interface_was_up){
2291
perror_plus("Failed to bring up interface");
2293
errno = argz_add(&interfaces_to_take_down,
2294
&interfaces_to_take_down_size,
2297
perror_plus("argz_add");
2302
if(debug and (interfaces_to_take_down == NULL)){
2303
fprintf_plus(stderr, "No interfaces were brought up\n");
2307
/* If we only got one interface, explicitly use only that one */
2308
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2310
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2313
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2320
ret = init_gnutls_global(pubkey, seckey, &mc);
2322
fprintf_plus(stderr, "init_gnutls_global failed\n");
2323
exitcode = EX_UNAVAILABLE;
2326
gnutls_initialized = true;
2333
/* Try /run/tmp before /tmp */
2334
tempdir = mkdtemp(run_tempdir);
2335
if(tempdir == NULL and errno == ENOENT){
2337
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2338
run_tempdir, old_tempdir);
2340
tempdir = mkdtemp(old_tempdir);
2342
if(tempdir == NULL){
2343
perror_plus("mkdtemp");
2351
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2352
fprintf_plus(stderr, "init_gpgme failed\n");
2353
exitcode = EX_UNAVAILABLE;
2356
gpgme_initialized = true;
2363
if(connect_to != NULL){
2364
/* Connect directly, do not use Zeroconf */
2365
/* (Mainly meant for debugging) */
2366
char *address = strrchr(connect_to, ':');
2368
if(address == NULL){
2369
fprintf_plus(stderr, "No colon in address\n");
2370
exitcode = EX_USAGE;
2380
tmpmax = strtoimax(address+1, &tmp, 10);
2381
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2382
or tmpmax != (in_port_t)tmpmax){
2383
fprintf_plus(stderr, "Bad port number\n");
2384
exitcode = EX_USAGE;
2392
port = (in_port_t)tmpmax;
2394
/* Colon in address indicates IPv6 */
2396
if(strchr(connect_to, ':') != NULL){
2398
/* Accept [] around IPv6 address - see RFC 5952 */
2399
if(connect_to[0] == '[' and address[-1] == ']')
2407
address = connect_to;
2413
while(not quit_now){
2414
ret = start_mandos_communication(address, port, if_index, af,
2416
if(quit_now or ret == 0){
2420
fprintf_plus(stderr, "Retrying in %d seconds\n",
2421
(int)retry_interval);
2423
sleep((unsigned int)retry_interval);
2427
exitcode = EXIT_SUCCESS;
553
2438
AvahiServerConfig config;
554
AvahiSServiceBrowser *sb = NULL;
555
const char db[] = "--debug";
558
int returncode = EXIT_SUCCESS;
559
char *basename = rindex(argv[0], '/');
560
if(basename == NULL){
566
char *program_name = malloc(strlen(basename) + sizeof(db));
568
if (program_name == NULL){
573
program_name[0] = '\0';
575
for (int i = 1; i < argc; i++){
576
if (not strncmp(argv[i], db, 5)){
577
strcat(strcat(strcat(program_name, db ), "="), basename);
578
if(not strcmp(argv[i], db) or not strcmp(argv[i], program_name)){
586
avahi_set_log_function(empty_log);
589
/* Initialize the psuedo-RNG */
592
/* Allocate main loop object */
593
if (!(simple_poll = avahi_simple_poll_new())) {
594
fprintf(stderr, "Failed to create simple poll object.\n");
599
/* Do not publish any local records */
2439
/* Do not publish any local Zeroconf records */
600
2440
avahi_server_config_init(&config);
601
2441
config.publish_hinfo = 0;
602
2442
config.publish_addresses = 0;
603
2443
config.publish_workstation = 0;
604
2444
config.publish_domain = 0;
606
2446
/* Allocate a new server */
607
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
609
/* Free the configuration data */
2447
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2448
&config, NULL, NULL, &ret_errno);
2450
/* Free the Avahi configuration data */
610
2451
avahi_server_config_free(&config);
612
/* Check if creating the server object succeeded */
614
fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
615
returncode = EXIT_FAILURE;
619
/* Create the service browser */
620
if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
621
fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
622
returncode = EXIT_FAILURE;
626
/* Run the main loop */
629
fprintf(stderr, "Starting avahi loop search\n");
632
avahi_simple_poll_loop(simple_poll);
637
fprintf(stderr, "%s exiting\n", argv[0]);
642
avahi_s_service_browser_free(sb);
645
avahi_server_free(server);
648
avahi_simple_poll_free(simple_poll);
2454
/* Check if creating the Avahi server object succeeded */
2455
if(mc.server == NULL){
2456
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2457
avahi_strerror(ret_errno));
2458
exitcode = EX_UNAVAILABLE;
2466
/* Create the Avahi service browser */
2467
sb = avahi_s_service_browser_new(mc.server, if_index,
2468
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2469
NULL, 0, browse_callback,
2472
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2473
avahi_strerror(avahi_server_errno(mc.server)));
2474
exitcode = EX_UNAVAILABLE;
2482
/* Run the main loop */
2485
fprintf_plus(stderr, "Starting Avahi loop search\n");
2488
ret = avahi_loop_with_timeout(simple_poll,
2489
(int)(retry_interval * 1000), &mc);
2491
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2492
(ret == 0) ? "successfully" : "with error");
2498
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2501
/* Cleanup things */
2502
free(mc.interfaces);
2505
avahi_s_service_browser_free(sb);
2507
if(mc.server != NULL)
2508
avahi_server_free(mc.server);
2510
if(simple_poll != NULL)
2511
avahi_simple_poll_free(simple_poll);
2513
if(gnutls_initialized){
2514
gnutls_certificate_free_credentials(mc.cred);
2515
gnutls_global_deinit();
2516
gnutls_dh_params_deinit(mc.dh_params);
2519
if(gpgme_initialized){
2520
gpgme_release(mc.ctx);
2523
/* Cleans up the circular linked list of Mandos servers the client
2525
if(mc.current_server != NULL){
2526
mc.current_server->prev->next = NULL;
2527
while(mc.current_server != NULL){
2528
server *next = mc.current_server->next;
2529
free(mc.current_server);
2530
mc.current_server = next;
2534
/* Re-raise privileges */
2536
ret_errno = raise_privileges();
2538
perror_plus("Failed to raise privileges");
2541
/* Run network hooks */
2542
run_network_hooks("stop", interfaces_hooks != NULL ?
2543
interfaces_hooks : "", delay);
2545
/* Take down the network interfaces which were brought up */
2547
char *interface = NULL;
2548
while((interface=argz_next(interfaces_to_take_down,
2549
interfaces_to_take_down_size,
2551
ret_errno = take_down_interface(interface);
2554
perror_plus("Failed to take down interface");
2557
if(debug and (interfaces_to_take_down == NULL)){
2558
fprintf_plus(stderr, "No interfaces needed to be taken"
2563
ret_errno = lower_privileges_permanently();
2565
perror_plus("Failed to lower privileges permanently");
2569
free(interfaces_to_take_down);
2570
free(interfaces_hooks);
2572
/* Removes the GPGME temp directory and all files inside */
2573
if(tempdir != NULL){
2574
struct dirent **direntries = NULL;
2575
struct dirent *direntry = NULL;
2576
int numentries = scandir(tempdir, &direntries, notdotentries,
2579
for(int i = 0; i < numentries; i++){
2580
direntry = direntries[i];
2581
char *fullname = NULL;
2582
ret = asprintf(&fullname, "%s/%s", tempdir,
2585
perror_plus("asprintf");
2588
ret = remove(fullname);
2590
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2597
/* need to clean even if 0 because man page doesn't specify */
2599
if(numentries == -1){
2600
perror_plus("scandir");
2602
ret = rmdir(tempdir);
2603
if(ret == -1 and errno != ENOENT){
2604
perror_plus("rmdir");
2609
sigemptyset(&old_sigterm_action.sa_mask);
2610
old_sigterm_action.sa_handler = SIG_DFL;
2611
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2612
&old_sigterm_action,
2615
perror_plus("sigaction");
2618
ret = raise(signal_received);
2619
} while(ret != 0 and errno == EINTR);
2621
perror_plus("raise");
2624
TEMP_FAILURE_RETRY(pause());