To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 723.1.4
- compare with another revision
- download diff
- download tarball
- view history from revision 723.1.4
- Committer: Teddy Hogeborn
- Date: 2014-07-25 23:16:04 UTC
- mto: This revision was merged to the branch mainline in revision 724.
- Revision ID: teddy@recompile.se-20140725231604-f5c4f82rn2o5ll1k
Use the .items() method instead of .iteritems().
This is strictly not a Python 2.7 change, but Python 2.7 backported
the new .viewitems() from Python 3, and instead of changing .items()
to .viewitems() and later having to change them all into .items()
again in Python 3, I opted to just change all .iteritems() to .items()
so the code will work both now and with Python 3. The slowdown with
Python 2 is not significant, and with Python 3 it will again be fast.
* mandos (Client.__init__): Use .items() instead of .iteritems().
(DBusObjectWithProperties.Introspect): - '' -
(alternate_dbus_interfaces/wrapper): - '' -
(main): - '' -
* mandos-ctl (main): - '' -
This is strictly not a Python 2.7 change, but Python 2.7 backported
the new .viewitems() from Python 3, and instead of changing .items()
to .viewitems() and later having to change them all into .items()
again in Python 3, I opted to just change all .iteritems() to .items()
so the code will work both now and with Python 3. The slowdown with
Python 2 is not significant, and with Python 3 it will again be fast.
* mandos (Client.__init__): Use .items() instead of .iteritems().
(DBusObjectWithProperties.Introspect): - '' -
(alternate_dbus_interfaces/wrapper): - '' -
(main): - '' -
* mandos-ctl (main): - '' -
- files added:
- debian/mandos-client.examples
- debian/upstream
- network-hooks.d
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 Björn Påhlsson
12
* Copyright © 2008-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 Björn Påhlsson
14
14
*
15
15
* This program is free software: you can redistribute it and/or
16
16
* modify it under the terms of the GNU General Public License as
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
#endif
35
#endif /* not _LARGEFILE_SOURCE */
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
#endif
38
#endif /* not _FILE_OFFSET_BITS */
39
39
40
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
42
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t */
43
stdout, ferror() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
47
strtof(), abort() */
53
53
sockaddr_in6, PF_INET6,
54
54
SOCK_STREAM, uid_t, gid_t, open(),
55
55
opendir(), DIR */
56
#include <sys/stat.h> /* open() */
56
#include <sys/stat.h> /* open(), S_ISREG */
57
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
58
inet_pton(), connect(),
59
getnameinfo() */
60
#include <fcntl.h> /* open(), unlinkat() */
60
61
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
62
*/
62
63
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
64
strtoimax() */
64
#include <assert.h> /* assert() */
65
65
#include <errno.h> /* perror(), errno,
66
66
program_invocation_short_name */
67
67
#include <time.h> /* nanosleep(), time(), sleep() */
73
73
*/
74
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
75
getuid(), getgid(), seteuid(),
76
setgid(), pause() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
76
setgid(), pause(), _exit(),
77
unlinkat() */
78
#include <arpa/inet.h> /* inet_pton(), htons() */
78
79
#include <iso646.h> /* not, or, and */
79
80
#include <argp.h> /* struct argp_option, error_t, struct
80
81
argp_state, struct argp,
85
86
raise() */
86
87
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
88
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
89
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
90
WEXITSTATUS(), WTERMSIG() */
91
#include <grp.h> /* setgroups() */
92
#include <argz.h> /* argz_add_sep(), argz_next(),
93
argz_delete(), argz_append(),
94
argz_stringify(), argz_add(),
95
argz_count() */
96
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
97
EAI_SYSTEM, gai_strerror() */
88
98
89
99
#ifdef __linux__
90
100
#include <sys/klog.h> /* klogctl() */
108
118
init_gnutls_session(),
109
119
GNUTLS_* */
110
120
#include <gnutls/openpgp.h>
111
/* gnutls_certificate_set_openpgp_key_file(),
112
GNUTLS_OPENPGP_FMT_BASE64 */
121
/* gnutls_certificate_set_openpgp_key_file(),
122
GNUTLS_OPENPGP_FMT_BASE64 */
113
123
114
124
/* GPGME */
115
125
#include <gpgme.h> /* All GPGME types, constants and
123
133
#define PATHDIR "/conf/conf.d/mandos"
124
134
#define SECKEY "seckey.txt"
125
135
#define PUBKEY "pubkey.txt"
136
#define HOOKDIR "/lib/mandos/network-hooks.d"
126
137
127
138
bool debug = false;
128
139
static const char mandos_protocol_version[] = "1";
130
141
const char *argp_program_bug_address = "<mandos@recompile.se>";
131
142
static const char sys_class_net[] = "/sys/class/net";
132
143
char *connect_to = NULL;
144
const char *hookdir = HOOKDIR;
145
int hookdir_fd = -1;
146
uid_t uid = 65534;
147
gid_t gid = 65534;
133
148
134
149
/* Doubly linked list that need to be circularly linked when used */
135
150
typedef struct server{
136
151
const char *ip;
137
uint16_t port;
152
in_port_t port;
138
153
AvahiIfIndex if_index;
139
154
int af;
140
155
struct timespec last_seen;
144
159
145
160
/* Used for passing in values through the Avahi callback functions */
146
161
typedef struct {
147
AvahiSimplePoll *simple_poll;
148
162
AvahiServer *server;
149
163
gnutls_certificate_credentials_t cred;
150
164
unsigned int dh_bits;
152
166
const char *priority;
153
167
gpgme_ctx_t ctx;
154
168
server *current_server;
169
char *interfaces;
170
size_t interfaces_size;
155
171
} mandos_context;
156
172
157
/* global context so signal handler can reach it*/
158
mandos_context mc = { .simple_poll = NULL, .server = NULL,
159
.dh_bits = 1024, .priority = "SECURE256"
160
":!CTYPE-X.509:+CTYPE-OPENPGP",
161
.current_server = NULL };
173
/* global so signal handler can reach it*/
174
AvahiSimplePoll *simple_poll;
162
175
163
176
sig_atomic_t quit_now = 0;
164
177
int signal_received = 0;
165
178
166
179
/* Function to use when printing errors */
167
180
void perror_plus(const char *print_text){
181
int e = errno;
168
182
fprintf(stderr, "Mandos plugin %s: ",
169
183
program_invocation_short_name);
184
errno = e;
170
185
perror(print_text);
171
186
}
172
187
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
189
int fprintf_plus(FILE *stream, const char *format, ...){
190
va_list ap;
191
va_start (ap, format);
192
193
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
194
program_invocation_short_name));
195
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
196
}
197
173
198
/*
174
199
* Make additional room in "buffer" for at least BUFFER_SIZE more
175
200
* bytes. "buffer_capacity" is how much is currently allocated,
176
201
* "buffer_length" is how much is already used.
177
202
*/
203
__attribute__((nonnull, warn_unused_result))
178
204
size_t incbuffer(char **buffer, size_t buffer_length,
179
size_t buffer_capacity){
205
size_t buffer_capacity){
180
206
if(buffer_length + BUFFER_SIZE > buffer_capacity){
181
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
182
if(buffer == NULL){
207
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
208
if(new_buf == NULL){
209
int old_errno = errno;
210
free(*buffer);
211
errno = old_errno;
212
*buffer = NULL;
183
213
return 0;
184
214
}
215
*buffer = new_buf;
185
216
buffer_capacity += BUFFER_SIZE;
186
217
}
187
218
return buffer_capacity;
188
219
}
189
220
190
221
/* Add server to set of servers to retry periodically */
191
int add_server(const char *ip, uint16_t port,
192
AvahiIfIndex if_index,
193
int af){
222
__attribute__((nonnull, warn_unused_result))
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
224
int af, server **current_server){
194
225
int ret;
195
226
server *new_server = malloc(sizeof(server));
196
227
if(new_server == NULL){
197
228
perror_plus("malloc");
198
return -1;
229
return false;
199
230
}
200
231
*new_server = (server){ .ip = strdup(ip),
201
.port = port,
202
.if_index = if_index,
203
.af = af };
232
.port = port,
233
.if_index = if_index,
234
.af = af };
204
235
if(new_server->ip == NULL){
205
236
perror_plus("strdup");
206
return -1;
237
free(new_server);
238
return false;
239
}
240
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
241
if(ret == -1){
242
perror_plus("clock_gettime");
243
#ifdef __GNUC__
244
#pragma GCC diagnostic push
245
#pragma GCC diagnostic ignored "-Wcast-qual"
246
#endif
247
free((char *)(new_server->ip));
248
#ifdef __GNUC__
249
#pragma GCC diagnostic pop
250
#endif
251
free(new_server);
252
return false;
207
253
}
208
254
/* Special case of first server */
209
if (mc.current_server == NULL){
255
if(*current_server == NULL){
210
256
new_server->next = new_server;
211
257
new_server->prev = new_server;
212
mc.current_server = new_server;
213
/* Place the new server last in the list */
258
*current_server = new_server;
214
259
} else {
215
new_server->next = mc.current_server;
216
new_server->prev = mc.current_server->prev;
260
/* Place the new server last in the list */
261
new_server->next = *current_server;
262
new_server->prev = (*current_server)->prev;
217
263
new_server->prev->next = new_server;
218
mc.current_server->prev = new_server;
219
}
220
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
221
if(ret == -1){
222
perror_plus("clock_gettime");
223
return -1;
224
}
225
return 0;
264
(*current_server)->prev = new_server;
265
}
266
return true;
226
267
}
227
268
228
269
/*
229
270
* Initialize GPGME.
230
271
*/
231
static bool init_gpgme(const char *seckey,
232
const char *pubkey, const char *tempdir){
272
__attribute__((nonnull, warn_unused_result))
273
static bool init_gpgme(const char * const seckey,
274
const char * const pubkey,
275
const char * const tempdir,
276
mandos_context *mc){
233
277
gpgme_error_t rc;
234
278
gpgme_engine_info_t engine_info;
235
279
236
237
280
/*
238
281
* Helper function to insert pub and seckey to the engine keyring.
239
282
*/
240
bool import_key(const char *filename){
283
bool import_key(const char * const filename){
241
284
int ret;
242
285
int fd;
243
286
gpgme_data_t pgp_data;
250
293
251
294
rc = gpgme_data_new_from_fd(&pgp_data, fd);
252
295
if(rc != GPG_ERR_NO_ERROR){
253
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
254
gpgme_strsource(rc), gpgme_strerror(rc));
296
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
297
gpgme_strsource(rc), gpgme_strerror(rc));
255
298
return false;
256
299
}
257
300
258
rc = gpgme_op_import(mc.ctx, pgp_data);
301
rc = gpgme_op_import(mc->ctx, pgp_data);
259
302
if(rc != GPG_ERR_NO_ERROR){
260
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
261
gpgme_strsource(rc), gpgme_strerror(rc));
303
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
304
gpgme_strsource(rc), gpgme_strerror(rc));
262
305
return false;
263
306
}
264
307
271
314
}
272
315
273
316
if(debug){
274
fprintf(stderr, "Initializing GPGME\n");
317
fprintf_plus(stderr, "Initializing GPGME\n");
275
318
}
276
319
277
320
/* Init GPGME */
278
321
gpgme_check_version(NULL);
279
322
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
280
323
if(rc != GPG_ERR_NO_ERROR){
281
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
282
gpgme_strsource(rc), gpgme_strerror(rc));
324
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
325
gpgme_strsource(rc), gpgme_strerror(rc));
283
326
return false;
284
327
}
285
328
286
329
/* Set GPGME home directory for the OpenPGP engine only */
287
330
rc = gpgme_get_engine_info(&engine_info);
288
331
if(rc != GPG_ERR_NO_ERROR){
289
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
290
gpgme_strsource(rc), gpgme_strerror(rc));
332
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
333
gpgme_strsource(rc), gpgme_strerror(rc));
291
334
return false;
292
335
}
293
336
while(engine_info != NULL){
299
342
engine_info = engine_info->next;
300
343
}
301
344
if(engine_info == NULL){
302
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
345
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
346
tempdir);
303
347
return false;
304
348
}
305
349
306
350
/* Create new GPGME "context" */
307
rc = gpgme_new(&(mc.ctx));
351
rc = gpgme_new(&(mc->ctx));
308
352
if(rc != GPG_ERR_NO_ERROR){
309
fprintf(stderr, "bad gpgme_new: %s: %s\n",
310
gpgme_strsource(rc), gpgme_strerror(rc));
353
fprintf_plus(stderr, "Mandos plugin mandos-client: "
354
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
355
gpgme_strerror(rc));
311
356
return false;
312
357
}
313
358
322
367
* Decrypt OpenPGP data.
323
368
* Returns -1 on error
324
369
*/
370
__attribute__((nonnull, warn_unused_result))
325
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
326
372
size_t crypto_size,
327
char **plaintext){
373
char **plaintext,
374
mandos_context *mc){
328
375
gpgme_data_t dh_crypto, dh_plain;
329
376
gpgme_error_t rc;
330
377
ssize_t ret;
332
379
ssize_t plaintext_length = 0;
333
380
334
381
if(debug){
335
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
382
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
336
383
}
337
384
338
385
/* Create new GPGME data buffer from memory cryptotext */
339
386
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
340
387
0);
341
388
if(rc != GPG_ERR_NO_ERROR){
342
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
343
gpgme_strsource(rc), gpgme_strerror(rc));
389
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
390
gpgme_strsource(rc), gpgme_strerror(rc));
344
391
return -1;
345
392
}
346
393
347
394
/* Create new empty GPGME data buffer for the plaintext */
348
395
rc = gpgme_data_new(&dh_plain);
349
396
if(rc != GPG_ERR_NO_ERROR){
350
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
351
gpgme_strsource(rc), gpgme_strerror(rc));
397
fprintf_plus(stderr, "Mandos plugin mandos-client: "
398
"bad gpgme_data_new: %s: %s\n",
399
gpgme_strsource(rc), gpgme_strerror(rc));
352
400
gpgme_data_release(dh_crypto);
353
401
return -1;
354
402
}
355
403
356
404
/* Decrypt data from the cryptotext data buffer to the plaintext
357
405
data buffer */
358
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
406
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
359
407
if(rc != GPG_ERR_NO_ERROR){
360
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
361
gpgme_strsource(rc), gpgme_strerror(rc));
408
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
409
gpgme_strsource(rc), gpgme_strerror(rc));
362
410
plaintext_length = -1;
363
411
if(debug){
364
412
gpgme_decrypt_result_t result;
365
result = gpgme_op_decrypt_result(mc.ctx);
413
result = gpgme_op_decrypt_result(mc->ctx);
366
414
if(result == NULL){
367
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
368
416
} else {
369
fprintf(stderr, "Unsupported algorithm: %s\n",
370
result->unsupported_algorithm);
371
fprintf(stderr, "Wrong key usage: %u\n",
372
result->wrong_key_usage);
417
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
418
result->unsupported_algorithm);
419
fprintf_plus(stderr, "Wrong key usage: %u\n",
420
result->wrong_key_usage);
373
421
if(result->file_name != NULL){
374
fprintf(stderr, "File name: %s\n", result->file_name);
422
fprintf_plus(stderr, "File name: %s\n", result->file_name);
375
423
}
376
424
gpgme_recipient_t recipient;
377
425
recipient = result->recipients;
378
426
while(recipient != NULL){
379
fprintf(stderr, "Public key algorithm: %s\n",
380
gpgme_pubkey_algo_name(recipient->pubkey_algo));
381
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
382
fprintf(stderr, "Secret key available: %s\n",
383
recipient->status == GPG_ERR_NO_SECKEY
384
? "No" : "Yes");
427
fprintf_plus(stderr, "Public key algorithm: %s\n",
428
gpgme_pubkey_algo_name
429
(recipient->pubkey_algo));
430
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
431
fprintf_plus(stderr, "Secret key available: %s\n",
432
recipient->status == GPG_ERR_NO_SECKEY
433
? "No" : "Yes");
385
434
recipient = recipient->next;
386
435
}
387
436
}
390
439
}
391
440
392
441
if(debug){
393
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
442
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
394
443
}
395
444
396
445
/* Seek back to the beginning of the GPGME plaintext data buffer */
403
452
*plaintext = NULL;
404
453
while(true){
405
454
plaintext_capacity = incbuffer(plaintext,
406
(size_t)plaintext_length,
407
plaintext_capacity);
455
(size_t)plaintext_length,
456
plaintext_capacity);
408
457
if(plaintext_capacity == 0){
409
perror_plus("incbuffer");
410
plaintext_length = -1;
411
goto decrypt_end;
458
perror_plus("incbuffer");
459
plaintext_length = -1;
460
goto decrypt_end;
412
461
}
413
462
414
463
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
427
476
}
428
477
429
478
if(debug){
430
fprintf(stderr, "Decrypted password is: ");
479
fprintf_plus(stderr, "Decrypted password is: ");
431
480
for(ssize_t i = 0; i < plaintext_length; i++){
432
481
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
433
482
}
444
493
return plaintext_length;
445
494
}
446
495
447
static const char * safer_gnutls_strerror(int value){
448
const char *ret = gnutls_strerror(value); /* Spurious warning from
449
-Wunreachable-code */
496
__attribute__((warn_unused_result))
497
static const char *safer_gnutls_strerror(int value){
498
const char *ret = gnutls_strerror(value);
450
499
if(ret == NULL)
451
500
ret = "(unknown)";
452
501
return ret;
453
502
}
454
503
455
504
/* GnuTLS log function callback */
505
__attribute__((nonnull))
456
506
static void debuggnutls(__attribute__((unused)) int level,
457
507
const char* string){
458
fprintf(stderr, "GnuTLS: %s", string);
508
fprintf_plus(stderr, "GnuTLS: %s", string);
459
509
}
460
510
511
__attribute__((nonnull, warn_unused_result))
461
512
static int init_gnutls_global(const char *pubkeyfilename,
462
const char *seckeyfilename){
513
const char *seckeyfilename,
514
mandos_context *mc){
463
515
int ret;
464
516
465
517
if(debug){
466
fprintf(stderr, "Initializing GnuTLS\n");
518
fprintf_plus(stderr, "Initializing GnuTLS\n");
467
519
}
468
520
469
521
ret = gnutls_global_init();
470
522
if(ret != GNUTLS_E_SUCCESS){
471
fprintf(stderr, "GnuTLS global_init: %s\n",
472
safer_gnutls_strerror(ret));
523
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
524
safer_gnutls_strerror(ret));
473
525
return -1;
474
526
}
475
527
482
534
}
483
535
484
536
/* OpenPGP credentials */
485
ret = gnutls_certificate_allocate_credentials(&mc.cred);
537
ret = gnutls_certificate_allocate_credentials(&mc->cred);
486
538
if(ret != GNUTLS_E_SUCCESS){
487
fprintf(stderr, "GnuTLS memory error: %s\n",
488
safer_gnutls_strerror(ret));
539
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
540
safer_gnutls_strerror(ret));
489
541
gnutls_global_deinit();
490
542
return -1;
491
543
}
492
544
493
545
if(debug){
494
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
495
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
496
seckeyfilename);
546
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
547
" secret key %s as GnuTLS credentials\n",
548
pubkeyfilename,
549
seckeyfilename);
497
550
}
498
551
499
552
ret = gnutls_certificate_set_openpgp_key_file
500
(mc.cred, pubkeyfilename, seckeyfilename,
553
(mc->cred, pubkeyfilename, seckeyfilename,
501
554
GNUTLS_OPENPGP_FMT_BASE64);
502
555
if(ret != GNUTLS_E_SUCCESS){
503
fprintf(stderr,
504
"Error[%d] while reading the OpenPGP key pair ('%s',"
505
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
506
fprintf(stderr, "The GnuTLS error is: %s\n",
507
safer_gnutls_strerror(ret));
556
fprintf_plus(stderr,
557
"Error[%d] while reading the OpenPGP key pair ('%s',"
558
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
559
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
560
safer_gnutls_strerror(ret));
508
561
goto globalfail;
509
562
}
510
563
511
564
/* GnuTLS server initialization */
512
ret = gnutls_dh_params_init(&mc.dh_params);
565
ret = gnutls_dh_params_init(&mc->dh_params);
513
566
if(ret != GNUTLS_E_SUCCESS){
514
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
515
" %s\n", safer_gnutls_strerror(ret));
567
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
568
" initialization: %s\n",
569
safer_gnutls_strerror(ret));
516
570
goto globalfail;
517
571
}
518
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
572
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
519
573
if(ret != GNUTLS_E_SUCCESS){
520
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
521
safer_gnutls_strerror(ret));
574
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
575
safer_gnutls_strerror(ret));
522
576
goto globalfail;
523
577
}
524
578
525
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
579
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
526
580
527
581
return 0;
528
582
529
583
globalfail:
530
584
531
gnutls_certificate_free_credentials(mc.cred);
585
gnutls_certificate_free_credentials(mc->cred);
532
586
gnutls_global_deinit();
533
gnutls_dh_params_deinit(mc.dh_params);
587
gnutls_dh_params_deinit(mc->dh_params);
534
588
return -1;
535
589
}
536
590
537
static int init_gnutls_session(gnutls_session_t *session){
591
__attribute__((nonnull, warn_unused_result))
592
static int init_gnutls_session(gnutls_session_t *session,
593
mandos_context *mc){
538
594
int ret;
539
595
/* GnuTLS session creation */
540
596
do {
544
600
}
545
601
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
546
602
if(ret != GNUTLS_E_SUCCESS){
547
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
548
safer_gnutls_strerror(ret));
603
fprintf_plus(stderr,
604
"Error in GnuTLS session initialization: %s\n",
605
safer_gnutls_strerror(ret));
549
606
}
550
607
551
608
{
552
609
const char *err;
553
610
do {
554
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
611
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
555
612
if(quit_now){
556
613
gnutls_deinit(*session);
557
614
return -1;
558
615
}
559
616
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
560
617
if(ret != GNUTLS_E_SUCCESS){
561
fprintf(stderr, "Syntax error at: %s\n", err);
562
fprintf(stderr, "GnuTLS error: %s\n",
563
safer_gnutls_strerror(ret));
618
fprintf_plus(stderr, "Syntax error at: %s\n", err);
619
fprintf_plus(stderr, "GnuTLS error: %s\n",
620
safer_gnutls_strerror(ret));
564
621
gnutls_deinit(*session);
565
622
return -1;
566
623
}
568
625
569
626
do {
570
627
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
571
mc.cred);
628
mc->cred);
572
629
if(quit_now){
573
630
gnutls_deinit(*session);
574
631
return -1;
575
632
}
576
633
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
577
634
if(ret != GNUTLS_E_SUCCESS){
578
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
579
safer_gnutls_strerror(ret));
635
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
636
safer_gnutls_strerror(ret));
580
637
gnutls_deinit(*session);
581
638
return -1;
582
639
}
584
641
/* ignore client certificate if any. */
585
642
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
586
643
587
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
644
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
588
645
589
646
return 0;
590
647
}
594
651
__attribute__((unused)) const char *txt){}
595
652
596
653
/* Called when a Mandos server is found */
597
static int start_mandos_communication(const char *ip, uint16_t port,
654
__attribute__((nonnull, warn_unused_result))
655
static int start_mandos_communication(const char *ip, in_port_t port,
598
656
AvahiIfIndex if_index,
599
int af){
657
int af, mandos_context *mc){
600
658
int ret, tcp_sd = -1;
601
659
ssize_t sret;
602
union {
603
struct sockaddr_in in;
604
struct sockaddr_in6 in6;
605
} to;
660
struct sockaddr_storage to;
606
661
char *buffer = NULL;
607
662
char *decrypted_buffer = NULL;
608
663
size_t buffer_length = 0;
627
682
pf = PF_INET;
628
683
break;
629
684
default:
630
fprintf(stderr, "Bad address family: %d\n", af);
685
fprintf_plus(stderr, "Bad address family: %d\n", af);
631
686
errno = EINVAL;
632
687
return -1;
633
688
}
634
689
635
ret = init_gnutls_session(&session);
690
/* If the interface is specified and we have a list of interfaces */
691
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
692
/* Check if the interface is one of the interfaces we are using */
693
bool match = false;
694
{
695
char *interface = NULL;
696
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
697
interface))){
698
if(if_nametoindex(interface) == (unsigned int)if_index){
699
match = true;
700
break;
701
}
702
}
703
}
704
if(not match){
705
/* This interface does not match any in the list, so we don't
706
connect to the server */
707
if(debug){
708
char interface[IF_NAMESIZE];
709
if(if_indextoname((unsigned int)if_index, interface) == NULL){
710
perror_plus("if_indextoname");
711
} else {
712
fprintf_plus(stderr, "Skipping server on non-used interface"
713
" \"%s\"\n",
714
if_indextoname((unsigned int)if_index,
715
interface));
716
}
717
}
718
return -1;
719
}
720
}
721
722
ret = init_gnutls_session(&session, mc);
636
723
if(ret != 0){
637
724
return -1;
638
725
}
639
726
640
727
if(debug){
641
fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
642
"\n", ip, port);
728
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
729
PRIuMAX "\n", ip, (uintmax_t)port);
643
730
}
644
731
645
732
tcp_sd = socket(pf, SOCK_STREAM, 0);
657
744
658
745
memset(&to, 0, sizeof(to));
659
746
if(af == AF_INET6){
660
to.in6.sin6_family = (sa_family_t)af;
661
ret = inet_pton(af, ip, &to.in6.sin6_addr);
747
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
748
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
662
749
} else { /* IPv4 */
663
to.in.sin_family = (sa_family_t)af;
664
ret = inet_pton(af, ip, &to.in.sin_addr);
750
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
751
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
665
752
}
666
753
if(ret < 0 ){
667
754
int e = errno;
671
758
}
672
759
if(ret == 0){
673
760
int e = errno;
674
fprintf(stderr, "Bad address: %s\n", ip);
761
fprintf_plus(stderr, "Bad address: %s\n", ip);
675
762
errno = e;
676
763
goto mandos_end;
677
764
}
678
765
if(af == AF_INET6){
679
to.in6.sin6_port = htons(port); /* Spurious warnings from
680
-Wconversion and
681
-Wunreachable-code */
682
683
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
684
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
685
-Wunreachable-code*/
766
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
767
if(IN6_IS_ADDR_LINKLOCAL
768
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
686
769
if(if_index == AVAHI_IF_UNSPEC){
687
fprintf(stderr, "An IPv6 link-local address is incomplete"
688
" without a network interface\n");
770
fprintf_plus(stderr, "An IPv6 link-local address is"
771
" incomplete without a network interface\n");
689
772
errno = EINVAL;
690
773
goto mandos_end;
691
774
}
692
775
/* Set the network interface number as scope */
693
to.in6.sin6_scope_id = (uint32_t)if_index;
776
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
694
777
}
695
778
} else {
696
to.in.sin_port = htons(port); /* Spurious warnings from
697
-Wconversion and
698
-Wunreachable-code */
779
((struct sockaddr_in *)&to)->sin_port = htons(port);
699
780
}
700
781
701
782
if(quit_now){
709
790
if(if_indextoname((unsigned int)if_index, interface) == NULL){
710
791
perror_plus("if_indextoname");
711
792
} else {
712
fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
713
ip, interface, port);
793
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
794
"\n", ip, interface, (uintmax_t)port);
714
795
}
715
796
} else {
716
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
717
port);
797
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
798
ip, (uintmax_t)port);
718
799
}
719
800
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
720
801
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
721
const char *pcret;
722
802
if(af == AF_INET6){
723
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
724
sizeof(addrstr));
803
ret = getnameinfo((struct sockaddr *)&to,
804
sizeof(struct sockaddr_in6),
805
addrstr, sizeof(addrstr), NULL, 0,
806
NI_NUMERICHOST);
725
807
} else {
726
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
727
sizeof(addrstr));
808
ret = getnameinfo((struct sockaddr *)&to,
809
sizeof(struct sockaddr_in),
810
addrstr, sizeof(addrstr), NULL, 0,
811
NI_NUMERICHOST);
728
812
}
729
if(pcret == NULL){
730
perror_plus("inet_ntop");
731
} else {
732
if(strcmp(addrstr, ip) != 0){
733
fprintf(stderr, "Canonical address form: %s\n", addrstr);
734
}
813
if(ret == EAI_SYSTEM){
814
perror_plus("getnameinfo");
815
} else if(ret != 0) {
816
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
817
} else if(strcmp(addrstr, ip) != 0){
818
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
735
819
}
736
820
}
737
821
741
825
}
742
826
743
827
if(af == AF_INET6){
744
ret = connect(tcp_sd, &to.in6, sizeof(to));
828
ret = connect(tcp_sd, (struct sockaddr *)&to,
829
sizeof(struct sockaddr_in6));
745
830
} else {
746
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
831
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
832
sizeof(struct sockaddr_in));
747
833
}
748
834
if(ret < 0){
749
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
835
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
750
836
int e = errno;
751
837
perror_plus("connect");
752
838
errno = e;
764
850
while(true){
765
851
size_t out_size = strlen(out);
766
852
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
767
out_size - written));
853
out_size - written));
768
854
if(ret == -1){
769
855
int e = errno;
770
856
perror_plus("write");
790
876
}
791
877
792
878
if(debug){
793
fprintf(stderr, "Establishing TLS session with %s\n", ip);
879
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
794
880
}
795
881
796
882
if(quit_now){
798
884
goto mandos_end;
799
885
}
800
886
801
/* Spurious warning from -Wint-to-pointer-cast */
802
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
887
/* This casting via intptr_t is to eliminate warning about casting
888
an int to a pointer type. This is exactly how the GnuTLS Guile
889
function "set-session-transport-fd!" does it. */
890
gnutls_transport_set_ptr(session,
891
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
803
892
804
893
if(quit_now){
805
894
errno = EINTR;
816
905
817
906
if(ret != GNUTLS_E_SUCCESS){
818
907
if(debug){
819
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
908
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
820
909
gnutls_perror(ret);
821
910
}
822
911
errno = EPROTO;
826
915
/* Read OpenPGP packet that contains the wanted password */
827
916
828
917
if(debug){
829
fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
830
ip);
918
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
919
" %s\n", ip);
831
920
}
832
921
833
922
while(true){
838
927
}
839
928
840
929
buffer_capacity = incbuffer(&buffer, buffer_length,
841
buffer_capacity);
930
buffer_capacity);
842
931
if(buffer_capacity == 0){
843
932
int e = errno;
844
933
perror_plus("incbuffer");
871
960
}
872
961
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
873
962
if(ret < 0){
874
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
963
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
964
"***\n");
875
965
gnutls_perror(ret);
876
966
errno = EPROTO;
877
967
goto mandos_end;
878
968
}
879
969
break;
880
970
default:
881
fprintf(stderr, "Unknown error while reading data from"
882
" encrypted session with Mandos server\n");
971
fprintf_plus(stderr, "Unknown error while reading data from"
972
" encrypted session with Mandos server\n");
883
973
gnutls_bye(session, GNUTLS_SHUT_RDWR);
884
974
errno = EIO;
885
975
goto mandos_end;
890
980
}
891
981
892
982
if(debug){
893
fprintf(stderr, "Closing TLS session\n");
983
fprintf_plus(stderr, "Closing TLS session\n");
894
984
}
895
985
896
986
if(quit_now){
908
998
909
999
if(buffer_length > 0){
910
1000
ssize_t decrypted_buffer_size;
911
decrypted_buffer_size = pgp_packet_decrypt(buffer,
912
buffer_length,
913
&decrypted_buffer);
1001
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1002
&decrypted_buffer, mc);
914
1003
if(decrypted_buffer_size >= 0){
915
1004
916
1005
written = 0;
926
1015
if(ret == 0 and ferror(stdout)){
927
1016
int e = errno;
928
1017
if(debug){
929
fprintf(stderr, "Error writing encrypted data: %s\n",
930
strerror(errno));
1018
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1019
strerror(errno));
931
1020
}
932
1021
errno = e;
933
1022
goto mandos_end;
964
1053
return retval;
965
1054
}
966
1055
1056
__attribute__((nonnull))
967
1057
static void resolve_callback(AvahiSServiceResolver *r,
968
1058
AvahiIfIndex interface,
969
1059
AvahiProtocol proto,
977
1067
AVAHI_GCC_UNUSED AvahiStringList *txt,
978
1068
AVAHI_GCC_UNUSED AvahiLookupResultFlags
979
1069
flags,
980
AVAHI_GCC_UNUSED void* userdata){
981
assert(r);
1070
void *mc){
1071
if(r == NULL){
1072
return;
1073
}
982
1074
983
1075
/* Called whenever a service has been resolved successfully or
984
1076
timed out */
985
1077
986
1078
if(quit_now){
1079
avahi_s_service_resolver_free(r);
987
1080
return;
988
1081
}
989
1082
990
1083
switch(event){
991
1084
default:
992
1085
case AVAHI_RESOLVER_FAILURE:
993
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
994
" of type '%s' in domain '%s': %s\n", name, type, domain,
995
avahi_strerror(avahi_server_errno(mc.server)));
1086
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1087
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1088
domain,
1089
avahi_strerror(avahi_server_errno
1090
(((mandos_context*)mc)->server)));
996
1091
break;
997
1092
998
1093
case AVAHI_RESOLVER_FOUND:
1000
1095
char ip[AVAHI_ADDRESS_STR_MAX];
1001
1096
avahi_address_snprint(ip, sizeof(ip), address);
1002
1097
if(debug){
1003
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
1004
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1005
ip, (intmax_t)interface, port);
1098
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1099
PRIdMAX ") on port %" PRIu16 "\n", name,
1100
host_name, ip, (intmax_t)interface, port);
1006
1101
}
1007
int ret = start_mandos_communication(ip, port, interface,
1008
avahi_proto_to_af(proto));
1102
int ret = start_mandos_communication(ip, (in_port_t)port,
1103
interface,
1104
avahi_proto_to_af(proto),
1105
mc);
1009
1106
if(ret == 0){
1010
avahi_simple_poll_quit(mc.simple_poll);
1107
avahi_simple_poll_quit(simple_poll);
1011
1108
} else {
1012
ret = add_server(ip, port, interface,
1013
avahi_proto_to_af(proto));
1109
if(not add_server(ip, (in_port_t)port, interface,
1110
avahi_proto_to_af(proto),
1111
&((mandos_context*)mc)->current_server)){
1112
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1113
" list\n", name);
1114
}
1014
1115
}
1015
1116
}
1016
1117
}
1026
1127
const char *domain,
1027
1128
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1028
1129
flags,
1029
AVAHI_GCC_UNUSED void* userdata){
1030
assert(b);
1130
void *mc){
1131
if(b == NULL){
1132
return;
1133
}
1031
1134
1032
1135
/* Called whenever a new services becomes available on the LAN or
1033
1136
is removed from the LAN */
1040
1143
default:
1041
1144
case AVAHI_BROWSER_FAILURE:
1042
1145
1043
fprintf(stderr, "(Avahi browser) %s\n",
1044
avahi_strerror(avahi_server_errno(mc.server)));
1045
avahi_simple_poll_quit(mc.simple_poll);
1146
fprintf_plus(stderr, "(Avahi browser) %s\n",
1147
avahi_strerror(avahi_server_errno
1148
(((mandos_context*)mc)->server)));
1149
avahi_simple_poll_quit(simple_poll);
1046
1150
return;
1047
1151
1048
1152
case AVAHI_BROWSER_NEW:
1051
1155
the callback function is called the Avahi server will free the
1052
1156
resolver for us. */
1053
1157
1054
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1055
name, type, domain, protocol, 0,
1056
resolve_callback, NULL) == NULL)
1057
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
1058
name, avahi_strerror(avahi_server_errno(mc.server)));
1158
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1159
interface, protocol, name, type,
1160
domain, protocol, 0,
1161
resolve_callback, mc) == NULL)
1162
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1163
" %s\n", name,
1164
avahi_strerror(avahi_server_errno
1165
(((mandos_context*)mc)->server)));
1059
1166
break;
1060
1167
1061
1168
case AVAHI_BROWSER_REMOVE:
1064
1171
case AVAHI_BROWSER_ALL_FOR_NOW:
1065
1172
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1066
1173
if(debug){
1067
fprintf(stderr, "No Mandos server found, still searching...\n");
1174
fprintf_plus(stderr, "No Mandos server found, still"
1175
" searching...\n");
1068
1176
}
1069
1177
break;
1070
1178
}
1079
1187
signal_received = sig;
1080
1188
int old_errno = errno;
1081
1189
/* set main loop to exit */
1082
if(mc.simple_poll != NULL){
1083
avahi_simple_poll_quit(mc.simple_poll);
1190
if(simple_poll != NULL){
1191
avahi_simple_poll_quit(simple_poll);
1084
1192
}
1085
1193
errno = old_errno;
1086
1194
}
1087
1195
1196
__attribute__((nonnull, warn_unused_result))
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1198
int ret;
1199
error_t ret_errno;
1200
1201
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1202
if(s < 0){
1203
ret_errno = errno;
1204
perror_plus("socket");
1205
errno = ret_errno;
1206
return false;
1207
}
1208
strcpy(ifr->ifr_name, ifname);
1209
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1210
if(ret == -1){
1211
if(debug){
1212
ret_errno = errno;
1213
perror_plus("ioctl SIOCGIFFLAGS");
1214
errno = ret_errno;
1215
}
1216
return false;
1217
}
1218
return true;
1219
}
1220
1221
__attribute__((nonnull, warn_unused_result))
1222
bool good_flags(const char *ifname, const struct ifreq *ifr){
1223
1224
/* Reject the loopback device */
1225
if(ifr->ifr_flags & IFF_LOOPBACK){
1226
if(debug){
1227
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1228
ifname);
1229
}
1230
return false;
1231
}
1232
/* Accept point-to-point devices only if connect_to is specified */
1233
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1234
if(debug){
1235
fprintf_plus(stderr, "Accepting point-to-point interface"
1236
" \"%s\"\n", ifname);
1237
}
1238
return true;
1239
}
1240
/* Otherwise, reject non-broadcast-capable devices */
1241
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1242
if(debug){
1243
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1244
" \"%s\"\n", ifname);
1245
}
1246
return false;
1247
}
1248
/* Reject non-ARP interfaces (including dummy interfaces) */
1249
if(ifr->ifr_flags & IFF_NOARP){
1250
if(debug){
1251
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1252
ifname);
1253
}
1254
return false;
1255
}
1256
1257
/* Accept this device */
1258
if(debug){
1259
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1260
}
1261
return true;
1262
}
1263
1088
1264
/*
1089
1265
* This function determines if a directory entry in /sys/class/net
1090
1266
* corresponds to an acceptable network device.
1091
1267
* (This function is passed to scandir(3) as a filter function.)
1092
1268
*/
1269
__attribute__((nonnull, warn_unused_result))
1093
1270
int good_interface(const struct dirent *if_entry){
1094
ssize_t ssret;
1095
char *flagname = NULL;
1096
1271
if(if_entry->d_name[0] == '.'){
1097
1272
return 0;
1098
1273
}
1099
int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1100
if_entry->d_name);
1101
if(ret < 0){
1102
perror_plus("asprintf");
1103
return 0;
1104
}
1105
int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1106
if(flags_fd == -1){
1107
perror_plus("open");
1108
free(flagname);
1109
return 0;
1110
}
1111
free(flagname);
1112
typedef short ifreq_flags; /* ifreq.ifr_flags in netdevice(7) */
1113
/* read line from flags_fd */
1114
ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1115
char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1116
flagstring[(size_t)to_read] = '\0';
1117
if(flagstring == NULL){
1118
perror_plus("malloc");
1119
close(flags_fd);
1120
return 0;
1121
}
1122
while(to_read > 0){
1123
ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1124
(size_t)to_read));
1125
if(ssret == -1){
1126
perror_plus("read");
1127
free(flagstring);
1128
close(flags_fd);
1129
return 0;
1130
}
1131
to_read -= ssret;
1132
if(ssret == 0){
1133
break;
1134
}
1135
}
1136
close(flags_fd);
1137
intmax_t tmpmax;
1138
char *tmp;
1139
errno = 0;
1140
tmpmax = strtoimax(flagstring, &tmp, 0);
1141
if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1142
and not (isspace(*tmp)))
1143
or tmpmax != (ifreq_flags)tmpmax){
1144
if(debug){
1145
fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1146
flagstring, if_entry->d_name);
1147
}
1148
free(flagstring);
1149
return 0;
1150
}
1151
free(flagstring);
1152
ifreq_flags flags = (ifreq_flags)tmpmax;
1153
/* Reject the loopback device */
1154
if(flags & IFF_LOOPBACK){
1155
if(debug){
1156
fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1157
if_entry->d_name);
1158
}
1159
return 0;
1160
}
1161
/* Accept point-to-point devices only if connect_to is specified */
1162
if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1163
if(debug){
1164
fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1165
if_entry->d_name);
1166
}
1167
return 1;
1168
}
1169
/* Otherwise, reject non-broadcast-capable devices */
1170
if(not (flags & IFF_BROADCAST)){
1171
if(debug){
1172
fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1173
if_entry->d_name);
1174
}
1175
return 0;
1176
}
1177
/* Reject non-ARP interfaces (including dummy interfaces) */
1178
if(flags & IFF_NOARP){
1179
if(debug){
1180
fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1181
if_entry->d_name);
1182
}
1183
return 0;
1184
}
1185
/* Accept this device */
1186
if(debug){
1187
fprintf(stderr, "Interface \"%s\" is acceptable\n",
1188
if_entry->d_name);
1274
1275
struct ifreq ifr;
1276
if(not get_flags(if_entry->d_name, &ifr)){
1277
if(debug){
1278
fprintf_plus(stderr, "Failed to get flags for interface "
1279
"\"%s\"\n", if_entry->d_name);
1280
}
1281
return 0;
1282
}
1283
1284
if(not good_flags(if_entry->d_name, &ifr)){
1285
return 0;
1189
1286
}
1190
1287
return 1;
1191
1288
}
1192
1289
1290
/*
1291
* This function determines if a network interface is up.
1292
*/
1293
__attribute__((nonnull, warn_unused_result))
1294
bool interface_is_up(const char *interface){
1295
struct ifreq ifr;
1296
if(not get_flags(interface, &ifr)){
1297
if(debug){
1298
fprintf_plus(stderr, "Failed to get flags for interface "
1299
"\"%s\"\n", interface);
1300
}
1301
return false;
1302
}
1303
1304
return (bool)(ifr.ifr_flags & IFF_UP);
1305
}
1306
1307
/*
1308
* This function determines if a network interface is running
1309
*/
1310
__attribute__((nonnull, warn_unused_result))
1311
bool interface_is_running(const char *interface){
1312
struct ifreq ifr;
1313
if(not get_flags(interface, &ifr)){
1314
if(debug){
1315
fprintf_plus(stderr, "Failed to get flags for interface "
1316
"\"%s\"\n", interface);
1317
}
1318
return false;
1319
}
1320
1321
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1322
}
1323
1324
__attribute__((nonnull, pure, warn_unused_result))
1193
1325
int notdotentries(const struct dirent *direntry){
1194
1326
/* Skip "." and ".." */
1195
1327
if(direntry->d_name[0] == '.'
1201
1333
return 1;
1202
1334
}
1203
1335
1204
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1336
/* Is this directory entry a runnable program? */
1337
__attribute__((nonnull, warn_unused_result))
1338
int runnable_hook(const struct dirent *direntry){
1339
int ret;
1340
size_t sret;
1341
struct stat st;
1342
1343
if((direntry->d_name)[0] == '\0'){
1344
/* Empty name? */
1345
return 0;
1346
}
1347
1348
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1349
"abcdefghijklmnopqrstuvwxyz"
1350
"0123456789"
1351
"_.-");
1352
if((direntry->d_name)[sret] != '\0'){
1353
/* Contains non-allowed characters */
1354
if(debug){
1355
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1356
direntry->d_name);
1357
}
1358
return 0;
1359
}
1360
1361
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1362
if(ret == -1){
1363
if(debug){
1364
perror_plus("Could not stat hook");
1365
}
1366
return 0;
1367
}
1368
if(not (S_ISREG(st.st_mode))){
1369
/* Not a regular file */
1370
if(debug){
1371
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1372
direntry->d_name);
1373
}
1374
return 0;
1375
}
1376
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1377
/* Not executable */
1378
if(debug){
1379
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1380
direntry->d_name);
1381
}
1382
return 0;
1383
}
1384
if(debug){
1385
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1386
direntry->d_name);
1387
}
1388
return 1;
1389
}
1390
1391
__attribute__((nonnull, warn_unused_result))
1392
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1393
mandos_context *mc){
1205
1394
int ret;
1206
1395
struct timespec now;
1207
1396
struct timespec waited_time;
1208
1397
intmax_t block_time;
1209
1398
1210
1399
while(true){
1211
if(mc.current_server == NULL){
1212
if (debug){
1213
fprintf(stderr,
1214
"Wait until first server is found. No timeout!\n");
1400
if(mc->current_server == NULL){
1401
if(debug){
1402
fprintf_plus(stderr, "Wait until first server is found."
1403
" No timeout!\n");
1215
1404
}
1216
1405
ret = avahi_simple_poll_iterate(s, -1);
1217
1406
} else {
1218
if (debug){
1219
fprintf(stderr, "Check current_server if we should run it,"
1220
" or wait\n");
1407
if(debug){
1408
fprintf_plus(stderr, "Check current_server if we should run"
1409
" it, or wait\n");
1221
1410
}
1222
1411
/* the current time */
1223
1412
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1228
1417
/* Calculating in ms how long time between now and server
1229
1418
who we visted longest time ago. Now - last seen. */
1230
1419
waited_time.tv_sec = (now.tv_sec
1231
- mc.current_server->last_seen.tv_sec);
1420
- mc->current_server->last_seen.tv_sec);
1232
1421
waited_time.tv_nsec = (now.tv_nsec
1233
- mc.current_server->last_seen.tv_nsec);
1422
- mc->current_server->last_seen.tv_nsec);
1234
1423
/* total time is 10s/10,000ms.
1235
1424
Converting to s from ms by dividing by 1,000,
1236
1425
and ns to ms by dividing by 1,000,000. */
1238
1427
- ((intmax_t)waited_time.tv_sec * 1000))
1239
1428
- ((intmax_t)waited_time.tv_nsec / 1000000));
1240
1429
1241
if (debug){
1242
fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);
1430
if(debug){
1431
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1432
block_time);
1243
1433
}
1244
1434
1245
1435
if(block_time <= 0){
1246
ret = start_mandos_communication(mc.current_server->ip,
1247
mc.current_server->port,
1248
mc.current_server->if_index,
1249
mc.current_server->af);
1436
ret = start_mandos_communication(mc->current_server->ip,
1437
mc->current_server->port,
1438
mc->current_server->if_index,
1439
mc->current_server->af, mc);
1250
1440
if(ret == 0){
1251
avahi_simple_poll_quit(mc.simple_poll);
1441
avahi_simple_poll_quit(s);
1252
1442
return 0;
1253
1443
}
1254
1444
ret = clock_gettime(CLOCK_MONOTONIC,
1255
&mc.current_server->last_seen);
1445
&mc->current_server->last_seen);
1256
1446
if(ret == -1){
1257
1447
perror_plus("clock_gettime");
1258
1448
return -1;
1259
1449
}
1260
mc.current_server = mc.current_server->next;
1450
mc->current_server = mc->current_server->next;
1261
1451
block_time = 0; /* Call avahi to find new Mandos
1262
1452
servers, but don't block */
1263
1453
}
1265
1455
ret = avahi_simple_poll_iterate(s, (int)block_time);
1266
1456
}
1267
1457
if(ret != 0){
1268
if (ret > 0 or errno != EINTR) {
1458
if(ret > 0 or errno != EINTR){
1269
1459
return (ret != 1) ? ret : 0;
1270
1460
}
1271
1461
}
1272
1462
}
1273
1463
}
1274
1464
1465
/* Set effective uid to 0, return errno */
1466
__attribute__((warn_unused_result))
1467
error_t raise_privileges(void){
1468
error_t old_errno = errno;
1469
error_t ret_errno = 0;
1470
if(seteuid(0) == -1){
1471
ret_errno = errno;
1472
}
1473
errno = old_errno;
1474
return ret_errno;
1475
}
1476
1477
/* Set effective and real user ID to 0. Return errno. */
1478
__attribute__((warn_unused_result))
1479
error_t raise_privileges_permanently(void){
1480
error_t old_errno = errno;
1481
error_t ret_errno = raise_privileges();
1482
if(ret_errno != 0){
1483
errno = old_errno;
1484
return ret_errno;
1485
}
1486
if(setuid(0) == -1){
1487
ret_errno = errno;
1488
}
1489
errno = old_errno;
1490
return ret_errno;
1491
}
1492
1493
/* Set effective user ID to unprivileged saved user ID */
1494
__attribute__((warn_unused_result))
1495
error_t lower_privileges(void){
1496
error_t old_errno = errno;
1497
error_t ret_errno = 0;
1498
if(seteuid(uid) == -1){
1499
ret_errno = errno;
1500
}
1501
errno = old_errno;
1502
return ret_errno;
1503
}
1504
1505
/* Lower privileges permanently */
1506
__attribute__((warn_unused_result))
1507
error_t lower_privileges_permanently(void){
1508
error_t old_errno = errno;
1509
error_t ret_errno = 0;
1510
if(setuid(uid) == -1){
1511
ret_errno = errno;
1512
}
1513
errno = old_errno;
1514
return ret_errno;
1515
}
1516
1517
__attribute__((nonnull))
1518
void run_network_hooks(const char *mode, const char *interface,
1519
const float delay){
1520
struct dirent **direntries = NULL;
1521
if(hookdir_fd == -1){
1522
hookdir_fd = open(hookdir, O_RDONLY);
1523
if(hookdir_fd == -1){
1524
if(errno == ENOENT){
1525
if(debug){
1526
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1527
" found\n", hookdir);
1528
}
1529
} else {
1530
perror_plus("open");
1531
}
1532
return;
1533
}
1534
}
1535
#ifdef __GLIBC__
1536
#if __GLIBC_PREREQ(2, 15)
1537
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1538
runnable_hook, alphasort);
1539
#else /* not __GLIBC_PREREQ(2, 15) */
1540
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1541
alphasort);
1542
#endif /* not __GLIBC_PREREQ(2, 15) */
1543
#else /* not __GLIBC__ */
1544
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1545
alphasort);
1546
#endif /* not __GLIBC__ */
1547
if(numhooks == -1){
1548
perror_plus("scandir");
1549
return;
1550
}
1551
struct dirent *direntry;
1552
int ret;
1553
int devnull = open("/dev/null", O_RDONLY);
1554
for(int i = 0; i < numhooks; i++){
1555
direntry = direntries[i];
1556
if(debug){
1557
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1558
direntry->d_name);
1559
}
1560
pid_t hook_pid = fork();
1561
if(hook_pid == 0){
1562
/* Child */
1563
/* Raise privileges */
1564
errno = raise_privileges_permanently();
1565
if(errno != 0){
1566
perror_plus("Failed to raise privileges");
1567
_exit(EX_NOPERM);
1568
}
1569
/* Set group */
1570
errno = 0;
1571
ret = setgid(0);
1572
if(ret == -1){
1573
perror_plus("setgid");
1574
_exit(EX_NOPERM);
1575
}
1576
/* Reset supplementary groups */
1577
errno = 0;
1578
ret = setgroups(0, NULL);
1579
if(ret == -1){
1580
perror_plus("setgroups");
1581
_exit(EX_NOPERM);
1582
}
1583
ret = dup2(devnull, STDIN_FILENO);
1584
if(ret == -1){
1585
perror_plus("dup2(devnull, STDIN_FILENO)");
1586
_exit(EX_OSERR);
1587
}
1588
ret = close(devnull);
1589
if(ret == -1){
1590
perror_plus("close");
1591
_exit(EX_OSERR);
1592
}
1593
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1594
if(ret == -1){
1595
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1596
_exit(EX_OSERR);
1597
}
1598
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1599
if(ret == -1){
1600
perror_plus("setenv");
1601
_exit(EX_OSERR);
1602
}
1603
ret = setenv("DEVICE", interface, 1);
1604
if(ret == -1){
1605
perror_plus("setenv");
1606
_exit(EX_OSERR);
1607
}
1608
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1609
if(ret == -1){
1610
perror_plus("setenv");
1611
_exit(EX_OSERR);
1612
}
1613
ret = setenv("MODE", mode, 1);
1614
if(ret == -1){
1615
perror_plus("setenv");
1616
_exit(EX_OSERR);
1617
}
1618
char *delaystring;
1619
ret = asprintf(&delaystring, "%f", (double)delay);
1620
if(ret == -1){
1621
perror_plus("asprintf");
1622
_exit(EX_OSERR);
1623
}
1624
ret = setenv("DELAY", delaystring, 1);
1625
if(ret == -1){
1626
free(delaystring);
1627
perror_plus("setenv");
1628
_exit(EX_OSERR);
1629
}
1630
free(delaystring);
1631
if(connect_to != NULL){
1632
ret = setenv("CONNECT", connect_to, 1);
1633
if(ret == -1){
1634
perror_plus("setenv");
1635
_exit(EX_OSERR);
1636
}
1637
}
1638
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
1639
if(hook_fd == -1){
1640
perror_plus("openat");
1641
_exit(EXIT_FAILURE);
1642
}
1643
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1644
perror_plus("close");
1645
_exit(EXIT_FAILURE);
1646
}
1647
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1648
environ) == -1){
1649
perror_plus("fexecve");
1650
_exit(EXIT_FAILURE);
1651
}
1652
} else {
1653
int status;
1654
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1655
perror_plus("waitpid");
1656
free(direntry);
1657
continue;
1658
}
1659
if(WIFEXITED(status)){
1660
if(WEXITSTATUS(status) != 0){
1661
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1662
" with status %d\n", direntry->d_name,
1663
WEXITSTATUS(status));
1664
free(direntry);
1665
continue;
1666
}
1667
} else if(WIFSIGNALED(status)){
1668
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1669
" signal %d\n", direntry->d_name,
1670
WTERMSIG(status));
1671
free(direntry);
1672
continue;
1673
} else {
1674
fprintf_plus(stderr, "Warning: network hook \"%s\""
1675
" crashed\n", direntry->d_name);
1676
free(direntry);
1677
continue;
1678
}
1679
}
1680
if(debug){
1681
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1682
direntry->d_name);
1683
}
1684
free(direntry);
1685
}
1686
free(direntries);
1687
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1688
perror_plus("close");
1689
} else {
1690
hookdir_fd = -1;
1691
}
1692
close(devnull);
1693
}
1694
1695
__attribute__((nonnull, warn_unused_result))
1696
error_t bring_up_interface(const char *const interface,
1697
const float delay){
1698
error_t old_errno = errno;
1699
int ret;
1700
struct ifreq network;
1701
unsigned int if_index = if_nametoindex(interface);
1702
if(if_index == 0){
1703
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1704
errno = old_errno;
1705
return ENXIO;
1706
}
1707
1708
if(quit_now){
1709
errno = old_errno;
1710
return EINTR;
1711
}
1712
1713
if(not interface_is_up(interface)){
1714
error_t ret_errno = 0, ioctl_errno = 0;
1715
if(not get_flags(interface, &network)){
1716
ret_errno = errno;
1717
fprintf_plus(stderr, "Failed to get flags for interface "
1718
"\"%s\"\n", interface);
1719
errno = old_errno;
1720
return ret_errno;
1721
}
1722
network.ifr_flags |= IFF_UP; /* set flag */
1723
1724
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1725
if(sd == -1){
1726
ret_errno = errno;
1727
perror_plus("socket");
1728
errno = old_errno;
1729
return ret_errno;
1730
}
1731
1732
if(quit_now){
1733
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1734
if(ret == -1){
1735
perror_plus("close");
1736
}
1737
errno = old_errno;
1738
return EINTR;
1739
}
1740
1741
if(debug){
1742
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1743
interface);
1744
}
1745
1746
/* Raise privileges */
1747
ret_errno = raise_privileges();
1748
if(ret_errno != 0){
1749
errno = ret_errno;
1750
perror_plus("Failed to raise privileges");
1751
}
1752
1753
#ifdef __linux__
1754
int ret_linux;
1755
bool restore_loglevel = false;
1756
if(ret_errno == 0){
1757
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1758
messages about the network interface to mess up the prompt */
1759
ret_linux = klogctl(8, NULL, 5);
1760
if(ret_linux == -1){
1761
perror_plus("klogctl");
1762
} else {
1763
restore_loglevel = true;
1764
}
1765
}
1766
#endif /* __linux__ */
1767
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1768
ioctl_errno = errno;
1769
#ifdef __linux__
1770
if(restore_loglevel){
1771
ret_linux = klogctl(7, NULL, 0);
1772
if(ret_linux == -1){
1773
perror_plus("klogctl");
1774
}
1775
}
1776
#endif /* __linux__ */
1777
1778
/* If raise_privileges() succeeded above */
1779
if(ret_errno == 0){
1780
/* Lower privileges */
1781
ret_errno = lower_privileges();
1782
if(ret_errno != 0){
1783
errno = ret_errno;
1784
perror_plus("Failed to lower privileges");
1785
}
1786
}
1787
1788
/* Close the socket */
1789
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1790
if(ret == -1){
1791
perror_plus("close");
1792
}
1793
1794
if(ret_setflags == -1){
1795
errno = ioctl_errno;
1796
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1797
errno = old_errno;
1798
return ioctl_errno;
1799
}
1800
} else if(debug){
1801
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1802
interface);
1803
}
1804
1805
/* Sleep checking until interface is running.
1806
Check every 0.25s, up to total time of delay */
1807
for(int i=0; i < delay * 4; i++){
1808
if(interface_is_running(interface)){
1809
break;
1810
}
1811
struct timespec sleeptime = { .tv_nsec = 250000000 };
1812
ret = nanosleep(&sleeptime, NULL);
1813
if(ret == -1 and errno != EINTR){
1814
perror_plus("nanosleep");
1815
}
1816
}
1817
1818
errno = old_errno;
1819
return 0;
1820
}
1821
1822
__attribute__((nonnull, warn_unused_result))
1823
error_t take_down_interface(const char *const interface){
1824
error_t old_errno = errno;
1825
struct ifreq network;
1826
unsigned int if_index = if_nametoindex(interface);
1827
if(if_index == 0){
1828
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1829
errno = old_errno;
1830
return ENXIO;
1831
}
1832
if(interface_is_up(interface)){
1833
error_t ret_errno = 0, ioctl_errno = 0;
1834
if(not get_flags(interface, &network) and debug){
1835
ret_errno = errno;
1836
fprintf_plus(stderr, "Failed to get flags for interface "
1837
"\"%s\"\n", interface);
1838
errno = old_errno;
1839
return ret_errno;
1840
}
1841
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1842
1843
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1844
if(sd == -1){
1845
ret_errno = errno;
1846
perror_plus("socket");
1847
errno = old_errno;
1848
return ret_errno;
1849
}
1850
1851
if(debug){
1852
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1853
interface);
1854
}
1855
1856
/* Raise privileges */
1857
ret_errno = raise_privileges();
1858
if(ret_errno != 0){
1859
errno = ret_errno;
1860
perror_plus("Failed to raise privileges");
1861
}
1862
1863
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1864
ioctl_errno = errno;
1865
1866
/* If raise_privileges() succeeded above */
1867
if(ret_errno == 0){
1868
/* Lower privileges */
1869
ret_errno = lower_privileges();
1870
if(ret_errno != 0){
1871
errno = ret_errno;
1872
perror_plus("Failed to lower privileges");
1873
}
1874
}
1875
1876
/* Close the socket */
1877
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1878
if(ret == -1){
1879
perror_plus("close");
1880
}
1881
1882
if(ret_setflags == -1){
1883
errno = ioctl_errno;
1884
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1885
errno = old_errno;
1886
return ioctl_errno;
1887
}
1888
} else if(debug){
1889
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1890
interface);
1891
}
1892
1893
errno = old_errno;
1894
return 0;
1895
}
1896
1275
1897
int main(int argc, char *argv[]){
1898
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1899
.priority = "SECURE256:!CTYPE-X.509:"
1900
"+CTYPE-OPENPGP", .current_server = NULL,
1901
.interfaces = NULL, .interfaces_size = 0 };
1276
1902
AvahiSServiceBrowser *sb = NULL;
1277
int error;
1903
error_t ret_errno;
1278
1904
int ret;
1279
1905
intmax_t tmpmax;
1280
1906
char *tmp;
1281
1907
int exitcode = EXIT_SUCCESS;
1282
const char *interface = "";
1283
struct ifreq network;
1284
int sd = -1;
1285
bool take_down_interface = false;
1286
uid_t uid;
1287
gid_t gid;
1288
char tempdir[] = "/tmp/mandosXXXXXX";
1289
bool tempdir_created = false;
1908
char *interfaces_to_take_down = NULL;
1909
size_t interfaces_to_take_down_size = 0;
1910
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
1911
char old_tempdir[] = "/tmp/mandosXXXXXX";
1912
char *tempdir = NULL;
1290
1913
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1291
1914
const char *seckey = PATHDIR "/" SECKEY;
1292
1915
const char *pubkey = PATHDIR "/" PUBKEY;
1916
char *interfaces_hooks = NULL;
1293
1917
1294
1918
bool gnutls_initialized = false;
1295
1919
bool gpgme_initialized = false;
1357
1981
.group = 2 },
1358
1982
{ .name = "retry", .key = 132,
1359
1983
.arg = "SECONDS",
1360
.doc = "Retry interval used when denied by the mandos server",
1984
.doc = "Retry interval used when denied by the Mandos server",
1985
.group = 2 },
1986
{ .name = "network-hook-dir", .key = 133,
1987
.arg = "DIR",
1988
.doc = "Directory where network hooks are located",
1361
1989
.group = 2 },
1362
1990
/*
1363
1991
* These reproduce what we would get without ARGP_NO_HELP
1382
2010
connect_to = arg;
1383
2011
break;
1384
2012
case 'i': /* --interface */
1385
interface = arg;
2013
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2014
arg, (int)',');
2015
if(ret_errno != 0){
2016
argp_error(state, "%s", strerror(ret_errno));
2017
}
1386
2018
break;
1387
2019
case 's': /* --seckey */
1388
2020
seckey = arg;
1417
2049
argp_error(state, "Bad retry interval");
1418
2050
}
1419
2051
break;
2052
case 133: /* --network-hook-dir */
2053
hookdir = arg;
2054
break;
1420
2055
/*
1421
2056
* These reproduce what we would get without ARGP_NO_HELP
1422
2057
*/
1428
2063
argp_state_help(state, state->out_stream,
1429
2064
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1430
2065
case 'V': /* --version */
1431
fprintf(state->out_stream, "%s\n", argp_program_version);
2066
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1432
2067
exit(argp_err_exit_status);
1433
2068
break;
1434
2069
default:
1461
2096
{
1462
2097
/* Work around Debian bug #633582:
1463
2098
<http://bugs.debian.org/633582> */
1464
struct stat st;
1465
1466
/* Re-raise priviliges */
1467
errno = 0;
1468
ret = seteuid(0);
1469
if(ret == -1){
1470
perror_plus("seteuid");
1471
}
1472
1473
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1474
int seckey_fd = open(seckey, O_RDONLY);
1475
if(seckey_fd == -1){
1476
perror_plus("open");
1477
} else {
1478
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1479
if(ret == -1){
1480
perror_plus("fstat");
1481
} else {
1482
if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1483
ret = fchown(seckey_fd, uid, gid);
1484
if(ret == -1){
1485
perror_plus("fchown");
1486
}
1487
}
1488
}
1489
TEMP_FAILURE_RETRY(close(seckey_fd));
1490
}
1491
}
1492
1493
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1494
int pubkey_fd = open(pubkey, O_RDONLY);
1495
if(pubkey_fd == -1){
1496
perror_plus("open");
1497
} else {
1498
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1499
if(ret == -1){
1500
perror_plus("fstat");
1501
} else {
1502
if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1503
ret = fchown(pubkey_fd, uid, gid);
1504
if(ret == -1){
1505
perror_plus("fchown");
1506
}
1507
}
1508
}
1509
TEMP_FAILURE_RETRY(close(pubkey_fd));
1510
}
1511
}
1512
1513
/* Lower privileges */
1514
errno = 0;
1515
ret = seteuid(uid);
1516
if(ret == -1){
1517
perror_plus("seteuid");
1518
}
2099
2100
/* Re-raise privileges */
2101
ret_errno = raise_privileges();
2102
if(ret_errno != 0){
2103
errno = ret_errno;
2104
perror_plus("Failed to raise privileges");
2105
} else {
2106
struct stat st;
2107
2108
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2109
int seckey_fd = open(seckey, O_RDONLY);
2110
if(seckey_fd == -1){
2111
perror_plus("open");
2112
} else {
2113
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2114
if(ret == -1){
2115
perror_plus("fstat");
2116
} else {
2117
if(S_ISREG(st.st_mode)
2118
and st.st_uid == 0 and st.st_gid == 0){
2119
ret = fchown(seckey_fd, uid, gid);
2120
if(ret == -1){
2121
perror_plus("fchown");
2122
}
2123
}
2124
}
2125
TEMP_FAILURE_RETRY(close(seckey_fd));
2126
}
2127
}
2128
2129
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2130
int pubkey_fd = open(pubkey, O_RDONLY);
2131
if(pubkey_fd == -1){
2132
perror_plus("open");
2133
} else {
2134
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2135
if(ret == -1){
2136
perror_plus("fstat");
2137
} else {
2138
if(S_ISREG(st.st_mode)
2139
and st.st_uid == 0 and st.st_gid == 0){
2140
ret = fchown(pubkey_fd, uid, gid);
2141
if(ret == -1){
2142
perror_plus("fchown");
2143
}
2144
}
2145
}
2146
TEMP_FAILURE_RETRY(close(pubkey_fd));
2147
}
2148
}
2149
2150
/* Lower privileges */
2151
ret_errno = lower_privileges();
2152
if(ret_errno != 0){
2153
errno = ret_errno;
2154
perror_plus("Failed to lower privileges");
2155
}
2156
}
2157
}
2158
2159
/* Remove invalid interface names (except "none") */
2160
{
2161
char *interface = NULL;
2162
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2163
interface))){
2164
if(strcmp(interface, "none") != 0
2165
and if_nametoindex(interface) == 0){
2166
if(interface[0] != '\0'){
2167
fprintf_plus(stderr, "Not using nonexisting interface"
2168
" \"%s\"\n", interface);
2169
}
2170
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2171
interface = NULL;
2172
}
2173
}
2174
}
2175
2176
/* Run network hooks */
2177
{
2178
if(mc.interfaces != NULL){
2179
interfaces_hooks = malloc(mc.interfaces_size);
2180
if(interfaces_hooks == NULL){
2181
perror_plus("malloc");
2182
goto end;
2183
}
2184
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2185
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2186
}
2187
run_network_hooks("start", interfaces_hooks != NULL ?
2188
interfaces_hooks : "", delay);
1519
2189
}
1520
2190
1521
2191
if(not debug){
1522
2192
avahi_set_log_function(empty_log);
1523
2193
}
1524
1525
if(interface[0] == '\0'){
1526
struct dirent **direntries;
1527
ret = scandir(sys_class_net, &direntries, good_interface,
1528
alphasort);
1529
if(ret >= 1){
1530
/* Pick the first good interface */
1531
interface = strdup(direntries[0]->d_name);
1532
if(debug){
1533
fprintf(stderr, "Using interface \"%s\"\n", interface);
1534
}
1535
if(interface == NULL){
1536
perror_plus("malloc");
1537
free(direntries);
1538
exitcode = EXIT_FAILURE;
1539
goto end;
1540
}
1541
free(direntries);
1542
} else {
1543
free(direntries);
1544
fprintf(stderr, "Could not find a network interface\n");
1545
exitcode = EXIT_FAILURE;
1546
goto end;
1547
}
1548
}
1549
2194
1550
2195
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1551
2196
from the signal handler */
1552
2197
/* Initialize the pseudo-RNG for Avahi */
1553
2198
srand((unsigned int) time(NULL));
1554
mc.simple_poll = avahi_simple_poll_new();
1555
if(mc.simple_poll == NULL){
1556
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
2199
simple_poll = avahi_simple_poll_new();
2200
if(simple_poll == NULL){
2201
fprintf_plus(stderr,
2202
"Avahi: Failed to create simple poll object.\n");
1557
2203
exitcode = EX_UNAVAILABLE;
1558
2204
goto end;
1559
2205
}
1621
2267
}
1622
2268
}
1623
2269
1624
/* If the interface is down, bring it up */
1625
if(strcmp(interface, "none") != 0){
1626
if_index = (AvahiIfIndex) if_nametoindex(interface);
1627
if(if_index == 0){
1628
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1629
exitcode = EX_UNAVAILABLE;
1630
goto end;
1631
}
1632
1633
if(quit_now){
1634
goto end;
1635
}
1636
1637
/* Re-raise priviliges */
1638
errno = 0;
1639
ret = seteuid(0);
1640
if(ret == -1){
1641
perror_plus("seteuid");
1642
}
1643
1644
#ifdef __linux__
1645
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1646
messages about the network interface to mess up the prompt */
1647
ret = klogctl(8, NULL, 5);
1648
bool restore_loglevel = true;
1649
if(ret == -1){
1650
restore_loglevel = false;
1651
perror_plus("klogctl");
1652
}
1653
#endif /* __linux__ */
1654
1655
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1656
if(sd < 0){
1657
perror_plus("socket");
1658
exitcode = EX_OSERR;
1659
#ifdef __linux__
1660
if(restore_loglevel){
1661
ret = klogctl(7, NULL, 0);
1662
if(ret == -1){
1663
perror_plus("klogctl");
1664
}
1665
}
1666
#endif /* __linux__ */
1667
/* Lower privileges */
1668
errno = 0;
1669
ret = seteuid(uid);
1670
if(ret == -1){
1671
perror_plus("seteuid");
1672
}
1673
goto end;
1674
}
1675
strcpy(network.ifr_name, interface);
1676
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1677
if(ret == -1){
1678
perror_plus("ioctl SIOCGIFFLAGS");
1679
#ifdef __linux__
1680
if(restore_loglevel){
1681
ret = klogctl(7, NULL, 0);
1682
if(ret == -1){
1683
perror_plus("klogctl");
1684
}
1685
}
1686
#endif /* __linux__ */
1687
exitcode = EX_OSERR;
1688
/* Lower privileges */
1689
errno = 0;
1690
ret = seteuid(uid);
1691
if(ret == -1){
1692
perror_plus("seteuid");
1693
}
1694
goto end;
1695
}
1696
if((network.ifr_flags & IFF_UP) == 0){
1697
network.ifr_flags |= IFF_UP;
1698
take_down_interface = true;
1699
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1700
if(ret == -1){
1701
take_down_interface = false;
1702
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1703
exitcode = EX_OSERR;
1704
#ifdef __linux__
1705
if(restore_loglevel){
1706
ret = klogctl(7, NULL, 0);
1707
if(ret == -1){
1708
perror_plus("klogctl");
2270
/* If no interfaces were specified, make a list */
2271
if(mc.interfaces == NULL){
2272
struct dirent **direntries = NULL;
2273
/* Look for any good interfaces */
2274
ret = scandir(sys_class_net, &direntries, good_interface,
2275
alphasort);
2276
if(ret >= 1){
2277
/* Add all found interfaces to interfaces list */
2278
for(int i = 0; i < ret; ++i){
2279
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2280
direntries[i]->d_name);
2281
if(ret_errno != 0){
2282
errno = ret_errno;
2283
perror_plus("argz_add");
2284
free(direntries[i]);
2285
continue;
2286
}
2287
if(debug){
2288
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2289
direntries[i]->d_name);
2290
}
2291
free(direntries[i]);
2292
}
2293
free(direntries);
2294
} else {
2295
if(ret == 0){
2296
free(direntries);
2297
}
2298
fprintf_plus(stderr, "Could not find a network interface\n");
2299
exitcode = EXIT_FAILURE;
2300
goto end;
2301
}
2302
}
2303
2304
/* Bring up interfaces which are down, and remove any "none"s */
2305
{
2306
char *interface = NULL;
2307
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2308
interface))){
2309
/* If interface name is "none", stop bringing up interfaces.
2310
Also remove all instances of "none" from the list */
2311
if(strcmp(interface, "none") == 0){
2312
argz_delete(&mc.interfaces, &mc.interfaces_size,
2313
interface);
2314
interface = NULL;
2315
while((interface = argz_next(mc.interfaces,
2316
mc.interfaces_size, interface))){
2317
if(strcmp(interface, "none") == 0){
2318
argz_delete(&mc.interfaces, &mc.interfaces_size,
2319
interface);
2320
interface = NULL;
1709
2321
}
1710
2322
}
1711
#endif /* __linux__ */
1712
/* Lower privileges */
1713
errno = 0;
1714
ret = seteuid(uid);
1715
if(ret == -1){
1716
perror_plus("seteuid");
1717
}
1718
goto end;
1719
}
1720
}
1721
/* Sleep checking until interface is running.
1722
Check every 0.25s, up to total time of delay */
1723
for(int i=0; i < delay * 4; i++){
1724
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1725
if(ret == -1){
1726
perror_plus("ioctl SIOCGIFFLAGS");
1727
} else if(network.ifr_flags & IFF_RUNNING){
1728
2323
break;
1729
2324
}
1730
struct timespec sleeptime = { .tv_nsec = 250000000 };
1731
ret = nanosleep(&sleeptime, NULL);
1732
if(ret == -1 and errno != EINTR){
1733
perror_plus("nanosleep");
1734
}
1735
}
1736
if(not take_down_interface){
1737
/* We won't need the socket anymore */
1738
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1739
if(ret == -1){
1740
perror_plus("close");
1741
}
1742
}
1743
#ifdef __linux__
1744
if(restore_loglevel){
1745
/* Restores kernel loglevel to default */
1746
ret = klogctl(7, NULL, 0);
1747
if(ret == -1){
1748
perror_plus("klogctl");
1749
}
1750
}
1751
#endif /* __linux__ */
1752
/* Lower privileges */
1753
errno = 0;
1754
if(take_down_interface){
1755
/* Lower privileges */
1756
ret = seteuid(uid);
1757
if(ret == -1){
1758
perror_plus("seteuid");
1759
}
1760
} else {
1761
/* Lower privileges permanently */
1762
ret = setuid(uid);
1763
if(ret == -1){
1764
perror_plus("setuid");
1765
}
1766
}
2325
bool interface_was_up = interface_is_up(interface);
2326
errno = bring_up_interface(interface, delay);
2327
if(not interface_was_up){
2328
if(errno != 0){
2329
perror_plus("Failed to bring up interface");
2330
} else {
2331
errno = argz_add(&interfaces_to_take_down,
2332
&interfaces_to_take_down_size,
2333
interface);
2334
if(errno != 0){
2335
perror_plus("argz_add");
2336
}
2337
}
2338
}
2339
}
2340
if(debug and (interfaces_to_take_down == NULL)){
2341
fprintf_plus(stderr, "No interfaces were brought up\n");
2342
}
2343
}
2344
2345
/* If we only got one interface, explicitly use only that one */
2346
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2347
if(debug){
2348
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2349
mc.interfaces);
2350
}
2351
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
1767
2352
}
1768
2353
1769
2354
if(quit_now){
1770
2355
goto end;
1771
2356
}
1772
2357
1773
ret = init_gnutls_global(pubkey, seckey);
2358
ret = init_gnutls_global(pubkey, seckey, &mc);
1774
2359
if(ret == -1){
1775
fprintf(stderr, "init_gnutls_global failed\n");
2360
fprintf_plus(stderr, "init_gnutls_global failed\n");
1776
2361
exitcode = EX_UNAVAILABLE;
1777
2362
goto end;
1778
2363
} else {
1783
2368
goto end;
1784
2369
}
1785
2370
1786
if(mkdtemp(tempdir) == NULL){
2371
/* Try /run/tmp before /tmp */
2372
tempdir = mkdtemp(run_tempdir);
2373
if(tempdir == NULL and errno == ENOENT){
2374
if(debug){
2375
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2376
run_tempdir, old_tempdir);
2377
}
2378
tempdir = mkdtemp(old_tempdir);
2379
}
2380
if(tempdir == NULL){
1787
2381
perror_plus("mkdtemp");
1788
2382
goto end;
1789
2383
}
1790
tempdir_created = true;
1791
2384
1792
2385
if(quit_now){
1793
2386
goto end;
1794
2387
}
1795
2388
1796
if(not init_gpgme(pubkey, seckey, tempdir)){
1797
fprintf(stderr, "init_gpgme failed\n");
2389
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2390
fprintf_plus(stderr, "init_gpgme failed\n");
1798
2391
exitcode = EX_UNAVAILABLE;
1799
2392
goto end;
1800
2393
} else {
1809
2402
/* Connect directly, do not use Zeroconf */
1810
2403
/* (Mainly meant for debugging) */
1811
2404
char *address = strrchr(connect_to, ':');
2405
1812
2406
if(address == NULL){
1813
fprintf(stderr, "No colon in address\n");
2407
fprintf_plus(stderr, "No colon in address\n");
1814
2408
exitcode = EX_USAGE;
1815
2409
goto end;
1816
2410
}
1819
2413
goto end;
1820
2414
}
1821
2415
1822
uint16_t port;
2416
in_port_t port;
1823
2417
errno = 0;
1824
2418
tmpmax = strtoimax(address+1, &tmp, 10);
1825
2419
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1826
or tmpmax != (uint16_t)tmpmax){
1827
fprintf(stderr, "Bad port number\n");
2420
or tmpmax != (in_port_t)tmpmax){
2421
fprintf_plus(stderr, "Bad port number\n");
1828
2422
exitcode = EX_USAGE;
1829
2423
goto end;
1830
2424
}
1831
2425
1832
2426
if(quit_now){
1833
2427
goto end;
1834
2428
}
1835
2429
1836
port = (uint16_t)tmpmax;
2430
port = (in_port_t)tmpmax;
1837
2431
*address = '\0';
1838
2432
/* Colon in address indicates IPv6 */
1839
2433
int af;
1855
2449
}
1856
2450
1857
2451
while(not quit_now){
1858
ret = start_mandos_communication(address, port, if_index, af);
2452
ret = start_mandos_communication(address, port, if_index, af,
2453
&mc);
1859
2454
if(quit_now or ret == 0){
1860
2455
break;
1861
2456
}
1862
2457
if(debug){
1863
fprintf(stderr, "Retrying in %d seconds\n",
1864
(int)retry_interval);
2458
fprintf_plus(stderr, "Retrying in %d seconds\n",
2459
(int)retry_interval);
1865
2460
}
1866
sleep((int)retry_interval);
2461
sleep((unsigned int)retry_interval);
1867
2462
}
1868
2463
1869
if (not quit_now){
2464
if(not quit_now){
1870
2465
exitcode = EXIT_SUCCESS;
1871
2466
}
1872
2467
1873
2468
goto end;
1874
2469
}
1875
2470
1887
2482
config.publish_domain = 0;
1888
2483
1889
2484
/* Allocate a new server */
1890
mc.server = avahi_server_new(avahi_simple_poll_get
1891
(mc.simple_poll), &config, NULL,
1892
NULL, &error);
2485
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2486
&config, NULL, NULL, &ret_errno);
1893
2487
1894
2488
/* Free the Avahi configuration data */
1895
2489
avahi_server_config_free(&config);
1897
2491
1898
2492
/* Check if creating the Avahi server object succeeded */
1899
2493
if(mc.server == NULL){
1900
fprintf(stderr, "Failed to create Avahi server: %s\n",
1901
avahi_strerror(error));
2494
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2495
avahi_strerror(ret_errno));
1902
2496
exitcode = EX_UNAVAILABLE;
1903
2497
goto end;
1904
2498
}
1910
2504
/* Create the Avahi service browser */
1911
2505
sb = avahi_s_service_browser_new(mc.server, if_index,
1912
2506
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1913
NULL, 0, browse_callback, NULL);
2507
NULL, 0, browse_callback,
2508
(void *)&mc);
1914
2509
if(sb == NULL){
1915
fprintf(stderr, "Failed to create service browser: %s\n",
1916
avahi_strerror(avahi_server_errno(mc.server)));
2510
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2511
avahi_strerror(avahi_server_errno(mc.server)));
1917
2512
exitcode = EX_UNAVAILABLE;
1918
2513
goto end;
1919
2514
}
1925
2520
/* Run the main loop */
1926
2521
1927
2522
if(debug){
1928
fprintf(stderr, "Starting Avahi loop search\n");
2523
fprintf_plus(stderr, "Starting Avahi loop search\n");
1929
2524
}
1930
1931
ret = avahi_loop_with_timeout(mc.simple_poll,
1932
(int)(retry_interval * 1000));
2525
2526
ret = avahi_loop_with_timeout(simple_poll,
2527
(int)(retry_interval * 1000), &mc);
1933
2528
if(debug){
1934
fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
1935
(ret == 0) ? "successfully" : "with error");
2529
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2530
(ret == 0) ? "successfully" : "with error");
1936
2531
}
1937
2532
1938
2533
end:
1939
2534
1940
2535
if(debug){
1941
fprintf(stderr, "%s exiting\n", argv[0]);
2536
fprintf_plus(stderr, "%s exiting\n", argv[0]);
1942
2537
}
1943
2538
1944
2539
/* Cleanup things */
2540
free(mc.interfaces);
2541
1945
2542
if(sb != NULL)
1946
2543
avahi_s_service_browser_free(sb);
1947
2544
1948
2545
if(mc.server != NULL)
1949
2546
avahi_server_free(mc.server);
1950
2547
1951
if(mc.simple_poll != NULL)
1952
avahi_simple_poll_free(mc.simple_poll);
2548
if(simple_poll != NULL)
2549
avahi_simple_poll_free(simple_poll);
1953
2550
1954
2551
if(gnutls_initialized){
1955
2552
gnutls_certificate_free_credentials(mc.cred);
1960
2557
if(gpgme_initialized){
1961
2558
gpgme_release(mc.ctx);
1962
2559
}
1963
2560
1964
2561
/* Cleans up the circular linked list of Mandos servers the client
1965
2562
has seen */
1966
2563
if(mc.current_server != NULL){
1967
2564
mc.current_server->prev->next = NULL;
1968
2565
while(mc.current_server != NULL){
1969
2566
server *next = mc.current_server->next;
2567
#ifdef __GNUC__
2568
#pragma GCC diagnostic push
2569
#pragma GCC diagnostic ignored "-Wcast-qual"
2570
#endif
2571
free((char *)(mc.current_server->ip));
2572
#ifdef __GNUC__
2573
#pragma GCC diagnostic pop
2574
#endif
1970
2575
free(mc.current_server);
1971
2576
mc.current_server = next;
1972
2577
}
1973
2578
}
1974
2579
1975
/* Take down the network interface */
1976
if(take_down_interface){
1977
/* Re-raise priviliges */
1978
errno = 0;
1979
ret = seteuid(0);
1980
if(ret == -1){
1981
perror_plus("seteuid");
2580
/* Re-raise privileges */
2581
{
2582
ret_errno = raise_privileges();
2583
if(ret_errno != 0){
2584
errno = ret_errno;
2585
perror_plus("Failed to raise privileges");
2586
} else {
2587
2588
/* Run network hooks */
2589
run_network_hooks("stop", interfaces_hooks != NULL ?
2590
interfaces_hooks : "", delay);
2591
2592
/* Take down the network interfaces which were brought up */
2593
{
2594
char *interface = NULL;
2595
while((interface=argz_next(interfaces_to_take_down,
2596
interfaces_to_take_down_size,
2597
interface))){
2598
ret_errno = take_down_interface(interface);
2599
if(ret_errno != 0){
2600
errno = ret_errno;
2601
perror_plus("Failed to take down interface");
2602
}
2603
}
2604
if(debug and (interfaces_to_take_down == NULL)){
2605
fprintf_plus(stderr, "No interfaces needed to be taken"
2606
" down\n");
2607
}
2608
}
1982
2609
}
1983
if(geteuid() == 0){
1984
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1985
if(ret == -1){
1986
perror_plus("ioctl SIOCGIFFLAGS");
1987
} else if(network.ifr_flags & IFF_UP) {
1988
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1989
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1990
if(ret == -1){
1991
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1992
}
1993
}
1994
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1995
if(ret == -1){
1996
perror_plus("close");
1997
}
1998
/* Lower privileges permanently */
1999
errno = 0;
2000
ret = setuid(uid);
2001
if(ret == -1){
2002
perror_plus("setuid");
2003
}
2610
2611
ret_errno = lower_privileges_permanently();
2612
if(ret_errno != 0){
2613
errno = ret_errno;
2614
perror_plus("Failed to lower privileges permanently");
2004
2615
}
2005
2616
}
2006
2617
2618
free(interfaces_to_take_down);
2619
free(interfaces_hooks);
2620
2007
2621
/* Removes the GPGME temp directory and all files inside */
2008
if(tempdir_created){
2622
if(tempdir != NULL){
2009
2623
struct dirent **direntries = NULL;
2010
struct dirent *direntry = NULL;
2011
int numentries = scandir(tempdir, &direntries, notdotentries,
2012
alphasort);
2013
if (numentries > 0){
2014
for(int i = 0; i < numentries; i++){
2015
direntry = direntries[i];
2016
char *fullname = NULL;
2017
ret = asprintf(&fullname, "%s/%s", tempdir,
2018
direntry->d_name);
2019
if(ret < 0){
2020
perror_plus("asprintf");
2021
continue;
2022
}
2023
ret = remove(fullname);
2024
if(ret == -1){
2025
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
2026
strerror(errno));
2027
}
2028
free(fullname);
2624
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2625
O_NOFOLLOW));
2626
if(tempdir_fd == -1){
2627
perror_plus("open");
2628
} else {
2629
#ifdef __GLIBC__
2630
#if __GLIBC_PREREQ(2, 15)
2631
int numentries = scandirat(tempdir_fd, ".", &direntries,
2632
notdotentries, alphasort);
2633
#else /* not __GLIBC_PREREQ(2, 15) */
2634
int numentries = scandir(tempdir, &direntries, notdotentries,
2635
alphasort);
2636
#endif /* not __GLIBC_PREREQ(2, 15) */
2637
#else /* not __GLIBC__ */
2638
int numentries = scandir(tempdir, &direntries, notdotentries,
2639
alphasort);
2640
#endif /* not __GLIBC__ */
2641
if(numentries >= 0){
2642
for(int i = 0; i < numentries; i++){
2643
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2644
if(ret == -1){
2645
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2646
" \"%s\", 0): %s\n", tempdir,
2647
direntries[i]->d_name, strerror(errno));
2648
}
2649
free(direntries[i]);
2650
}
2651
2652
/* need to clean even if 0 because man page doesn't specify */
2653
free(direntries);
2654
if(numentries == -1){
2655
perror_plus("scandir");
2656
}
2657
ret = rmdir(tempdir);
2658
if(ret == -1 and errno != ENOENT){
2659
perror_plus("rmdir");
2660
}
2029
2661
}
2030
}
2031
2032
/* need to clean even if 0 because man page doesn't specify */
2033
free(direntries);
2034
if (numentries == -1){
2035
perror_plus("scandir");
2036
}
2037
ret = rmdir(tempdir);
2038
if(ret == -1 and errno != ENOENT){
2039
perror_plus("rmdir");
2662
TEMP_FAILURE_RETRY(close(tempdir_fd));
2040
2663
}
2041
2664
}
2042
2665
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0