32
32
#define _LARGEFILE_SOURCE
33
33
#define _FILE_OFFSET_BITS 64
35
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
37
#include <stdio.h> /* fprintf(), stderr, fwrite(), stdout,
39
#include <stdint.h> /* uint16_t, uint32_t */
40
#include <stddef.h> /* NULL, size_t, ssize_t */
41
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
43
#include <stdbool.h> /* bool, true */
44
#include <string.h> /* memset(), strcmp(), strlen(),
45
strerror(), memcpy(), strcpy() */
46
#include <sys/ioctl.h> /* ioctl */
47
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
48
sockaddr_in6, PF_INET6,
49
SOCK_STREAM, INET6_ADDRSTRLEN,
51
#include <inttypes.h> /* PRIu16 */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton(),
55
#include <assert.h> /* assert() */
56
#include <errno.h> /* perror(), errno */
57
#include <time.h> /* time() */
58
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
59
SIOCSIFFLAGS, if_indextoname(),
60
if_nametoindex(), IF_NAMESIZE */
61
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
62
getuid(), getgid(), setuid(),
64
#include <netinet/in.h>
65
#include <arpa/inet.h> /* inet_pton(), htons */
66
#include <iso646.h> /* not, and */
67
#include <argp.h> /* struct argp_option, error_t, struct
68
argp_state, struct argp,
69
argp_parse(), ARGP_KEY_ARG,
70
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
73
/* All Avahi types, constants and functions
39
#include <net/if.h> /* if_nametoindex */
76
41
#include <avahi-core/core.h>
77
42
#include <avahi-core/lookup.h>
78
43
#include <avahi-core/log.h>
80
45
#include <avahi-common/malloc.h>
81
46
#include <avahi-common/error.h>
84
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and functions
86
init_gnutls_session(),
88
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
89
GNUTLS_OPENPGP_FMT_BASE64 */
92
#include <gpgme.h> /* All GPGME types, constants and functions
94
GPGME_PROTOCOL_OpenPGP,
49
#include <sys/types.h> /* socket(), inet_pton() */
50
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
51
struct in6_addr, inet_pton() */
52
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
53
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
55
#include <unistd.h> /* close() */
56
#include <netinet/in.h>
57
#include <stdbool.h> /* true */
58
#include <string.h> /* memset */
59
#include <arpa/inet.h> /* inet_pton() */
60
#include <iso646.h> /* not */
63
#include <errno.h> /* perror() */
97
69
#define BUFFER_SIZE 256
72
const char *certdir = "/conf/conf.d/cryptkeyreq/";
73
const char *certfile = "openpgp-client.txt";
74
const char *certkey = "openpgp-client-key.txt";
99
76
bool debug = false;
100
static const char *keydir = "/conf/conf.d/mandos";
101
static const char mandos_protocol_version[] = "1";
102
const char *argp_program_version = "password-request 1.0";
103
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
105
/* Used for passing in values through the Avahi callback functions */
107
AvahiSimplePoll *simple_poll;
79
gnutls_session_t session;
109
80
gnutls_certificate_credentials_t cred;
110
unsigned int dh_bits;
111
81
gnutls_dh_params_t dh_params;
112
const char *priority;
116
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
117
* "buffer_capacity" is how much is currently allocated,
118
* "buffer_length" is how much is already used.
120
size_t adjustbuffer(char **buffer, size_t buffer_length,
121
size_t buffer_capacity){
122
if (buffer_length + BUFFER_SIZE > buffer_capacity){
123
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
127
buffer_capacity += BUFFER_SIZE;
129
return buffer_capacity;
133
* Decrypt OpenPGP data using keyrings in HOMEDIR.
134
* Returns -1 on error
136
static ssize_t pgp_packet_decrypt (const char *cryptotext,
139
const char *homedir){
85
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
86
char **new_packet, const char *homedir){
140
87
gpgme_data_t dh_crypto, dh_plain;
144
size_t plaintext_capacity = 0;
145
ssize_t plaintext_length = 0;
91
ssize_t new_packet_capacity = 0;
92
ssize_t new_packet_length = 0;
146
93
gpgme_engine_info_t engine_info;
149
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
96
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
194
/* Delete the GPGME FILE pointer cryptotext data buffer */
195
gpgme_data_release(dh_crypto);
251
197
/* Seek back to the beginning of the GPGME plaintext data buffer */
252
198
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
253
199
perror("pgpme_data_seek");
254
plaintext_length = -1;
260
plaintext_capacity = adjustbuffer(plaintext,
261
(size_t)plaintext_length,
263
if (plaintext_capacity == 0){
264
perror("adjustbuffer");
265
plaintext_length = -1;
204
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
205
*new_packet = realloc(*new_packet,
206
(unsigned int)new_packet_capacity
208
if (*new_packet == NULL){
212
new_packet_capacity += BUFFER_SIZE;
269
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
215
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
271
217
/* Print the data, if any */
277
222
perror("gpgme_data_read");
278
plaintext_length = -1;
281
plaintext_length += ret;
225
new_packet_length += ret;
285
fprintf(stderr, "Decrypted password is: ");
286
for(ssize_t i = 0; i < plaintext_length; i++){
287
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
289
fprintf(stderr, "\n");
294
/* Delete the GPGME cryptotext data buffer */
295
gpgme_data_release(dh_crypto);
228
/* FIXME: check characters before printing to screen so to not print
229
terminal control characters */
231
/* fprintf(stderr, "decrypted password is: "); */
232
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
233
/* fprintf(stderr, "\n"); */
297
236
/* Delete the GPGME plaintext data buffer */
298
237
gpgme_data_release(dh_plain);
299
return plaintext_length;
238
return new_packet_length;
302
241
static const char * safer_gnutls_strerror (int value) {
309
/* GnuTLS log function callback */
310
static void debuggnutls(__attribute__((unused)) int level,
312
fprintf(stderr, "GnuTLS: %s", string);
248
void debuggnutls(__attribute__((unused)) int level,
250
fprintf(stderr, "%s", string);
315
static int init_gnutls_global(mandos_context *mc,
316
const char *pubkeyfile,
317
const char *seckeyfile){
253
int initgnutls(encrypted_session *es){
321
258
fprintf(stderr, "Initializing GnuTLS\n");
324
ret = gnutls_global_init();
325
if (ret != GNUTLS_E_SUCCESS) {
326
fprintf (stderr, "GnuTLS global_init: %s\n",
327
safer_gnutls_strerror(ret));
261
if ((ret = gnutls_global_init ())
262
!= GNUTLS_E_SUCCESS) {
263
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
332
/* "Use a log level over 10 to enable all debugging options."
335
268
gnutls_global_set_log_level(11);
336
269
gnutls_global_set_log_function(debuggnutls);
339
/* OpenPGP credentials */
340
gnutls_certificate_allocate_credentials(&mc->cred);
341
if (ret != GNUTLS_E_SUCCESS){
342
fprintf (stderr, "GnuTLS memory error: %s\n",
272
/* openpgp credentials */
273
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
274
!= GNUTLS_E_SUCCESS) {
275
fprintf (stderr, "memory error: %s\n",
343
276
safer_gnutls_strerror(ret));
344
gnutls_global_deinit ();
349
281
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
350
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
282
" and keyfile %s as GnuTLS credentials\n", certfile,
354
286
ret = gnutls_certificate_set_openpgp_key_file
355
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
287
(es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
356
288
if (ret != GNUTLS_E_SUCCESS) {
358
"Error[%d] while reading the OpenPGP key pair ('%s',"
359
" '%s')\n", ret, pubkeyfile, seckeyfile);
360
fprintf(stdout, "The GnuTLS error is: %s\n",
290
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
292
ret, certfile, certkey);
293
fprintf(stdout, "The Error is: %s\n",
361
294
safer_gnutls_strerror(ret));
365
/* GnuTLS server initialization */
366
ret = gnutls_dh_params_init(&mc->dh_params);
367
if (ret != GNUTLS_E_SUCCESS) {
368
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
369
" %s\n", safer_gnutls_strerror(ret));
372
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
373
if (ret != GNUTLS_E_SUCCESS) {
374
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
375
safer_gnutls_strerror(ret));
379
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
385
gnutls_certificate_free_credentials(mc->cred);
386
gnutls_global_deinit();
391
static int init_gnutls_session(mandos_context *mc,
392
gnutls_session_t *session){
394
/* GnuTLS session creation */
395
ret = gnutls_init(session, GNUTLS_SERVER);
396
if (ret != GNUTLS_E_SUCCESS){
298
//GnuTLS server initialization
299
if ((ret = gnutls_dh_params_init (&es->dh_params))
300
!= GNUTLS_E_SUCCESS) {
301
fprintf (stderr, "Error in dh parameter initialization: %s\n",
302
safer_gnutls_strerror(ret));
306
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
307
!= GNUTLS_E_SUCCESS) {
308
fprintf (stderr, "Error in prime generation: %s\n",
309
safer_gnutls_strerror(ret));
313
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
315
// GnuTLS session creation
316
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
317
!= GNUTLS_E_SUCCESS){
397
318
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
398
319
safer_gnutls_strerror(ret));
403
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
404
if (ret != GNUTLS_E_SUCCESS) {
405
fprintf(stderr, "Syntax error at: %s\n", err);
406
fprintf(stderr, "GnuTLS error: %s\n",
407
safer_gnutls_strerror(ret));
408
gnutls_deinit (*session);
322
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
323
!= GNUTLS_E_SUCCESS) {
324
fprintf(stderr, "Syntax error at: %s\n", err);
325
fprintf(stderr, "GnuTLS error: %s\n",
326
safer_gnutls_strerror(ret));
413
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
415
if (ret != GNUTLS_E_SUCCESS) {
416
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
330
if ((ret = gnutls_credentials_set
331
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
332
!= GNUTLS_E_SUCCESS) {
333
fprintf(stderr, "Error setting a credentials set: %s\n",
417
334
safer_gnutls_strerror(ret));
418
gnutls_deinit (*session);
422
338
/* ignore client certificate if any. */
423
gnutls_certificate_server_set_request (*session,
339
gnutls_certificate_server_set_request (es->session,
424
340
GNUTLS_CERT_IGNORE);
426
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
342
gnutls_dh_set_prime_bits (es->session, DH_BITS);
431
/* Avahi log function callback */
432
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
433
__attribute__((unused)) const char *txt){}
347
void empty_log(__attribute__((unused)) AvahiLogLevel level,
348
__attribute__((unused)) const char *txt){}
435
/* Called when a Mandos server is found */
436
static int start_mandos_communication(const char *ip, uint16_t port,
437
AvahiIfIndex if_index,
350
int start_mandos_communication(const char *ip, uint16_t port,
351
AvahiIfIndex if_index){
440
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
353
struct sockaddr_in6 to;
354
encrypted_session es;
441
355
char *buffer = NULL;
442
356
char *decrypted_buffer;
443
357
size_t buffer_length = 0;
444
358
size_t buffer_capacity = 0;
445
359
ssize_t decrypted_buffer_size;
448
362
char interface[IF_NAMESIZE];
449
gnutls_session_t session;
451
ret = init_gnutls_session (mc, &session);
457
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
365
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
461
369
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
463
371
perror("socket");
468
if(if_indextoname((unsigned int)if_index, interface) == NULL){
375
if(if_indextoname((unsigned int)if_index, interface) == NULL){
469
377
perror("if_indextoname");
472
383
fprintf(stderr, "Binding to interface %s\n", interface);
475
386
memset(&to,0,sizeof(to)); /* Spurious warning */
476
to.in6.sin6_family = AF_INET6;
477
/* It would be nice to have a way to detect if we were passed an
478
IPv4 address here. Now we assume an IPv6 address. */
479
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
387
to.sin6_family = AF_INET6;
388
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
481
390
perror("inet_pton");
485
394
fprintf(stderr, "Bad address: %s\n", ip);
488
to.in6.sin6_port = htons(port); /* Spurious warning */
397
to.sin6_port = htons(port); /* Spurious warning */
490
to.in6.sin6_scope_id = (uint32_t)if_index;
399
to.sin6_scope_id = (uint32_t)if_index;
493
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
495
char addrstr[INET6_ADDRSTRLEN] = "";
496
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
497
sizeof(addrstr)) == NULL){
500
if(strcmp(addrstr, ip) != 0){
501
fprintf(stderr, "Canonical address form: %s\n", addrstr);
402
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
403
/* char addrstr[INET6_ADDRSTRLEN]; */
404
/* if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr, */
405
/* sizeof(addrstr)) == NULL){ */
406
/* perror("inet_ntop"); */
408
/* fprintf(stderr, "Really connecting to: %s, port %d\n", */
409
/* addrstr, ntohs(to.sin6_port)); */
506
ret = connect(tcp_sd, &to.in, sizeof(to));
413
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
508
415
perror("connect");
512
const char *out = mandos_protocol_version;
515
size_t out_size = strlen(out);
516
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
517
out_size - written));
523
written += (size_t)ret;
524
if(written < out_size){
527
if (out == mandos_protocol_version){
419
ret = initgnutls (&es);
425
gnutls_transport_set_ptr (es.session,
426
(gnutls_transport_ptr_t) tcp_sd);
537
429
fprintf(stderr, "Establishing TLS session with %s\n", ip);
540
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
543
ret = gnutls_handshake (session);
544
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
432
ret = gnutls_handshake (es.session);
546
434
if (ret != GNUTLS_E_SUCCESS){
548
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
436
fprintf(stderr, "\n*** Handshake failed ***\n");
549
437
gnutls_perror (ret);
555
/* Read OpenPGP packet that contains the wanted password */
443
//Retrieve OpenPGP packet that contains the wanted password
558
446
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
676
566
char ip[AVAHI_ADDRESS_STR_MAX];
677
567
avahi_address_snprint(ip, sizeof(ip), address);
679
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
680
PRIu16 ") on port %d\n", name, host_name, ip,
569
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
570
" port %d\n", name, host_name, ip, port);
683
int ret = start_mandos_communication(ip, port, interface, mc);
572
int ret = start_mandos_communication(ip, port, interface);
685
avahi_simple_poll_quit(mc->simple_poll);
689
578
avahi_s_service_resolver_free(r);
692
static void browse_callback( AvahiSServiceBrowser *b,
693
AvahiIfIndex interface,
694
AvahiProtocol protocol,
695
AvahiBrowserEvent event,
699
AVAHI_GCC_UNUSED AvahiLookupResultFlags
702
mandos_context *mc = userdata;
703
assert(b); /* Spurious warning */
705
/* Called whenever a new services becomes available on the LAN or
706
is removed from the LAN */
710
case AVAHI_BROWSER_FAILURE:
712
fprintf(stderr, "(Avahi browser) %s\n",
713
avahi_strerror(avahi_server_errno(mc->server)));
714
avahi_simple_poll_quit(mc->simple_poll);
717
case AVAHI_BROWSER_NEW:
718
/* We ignore the returned Avahi resolver object. In the callback
719
function we free it. If the Avahi server is terminated before
720
the callback function is called the Avahi server will free the
723
if (!(avahi_s_service_resolver_new(mc->server, interface,
724
protocol, name, type, domain,
725
AVAHI_PROTO_INET6, 0,
726
resolve_callback, mc)))
727
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
728
name, avahi_strerror(avahi_server_errno(mc->server)));
731
case AVAHI_BROWSER_REMOVE:
734
case AVAHI_BROWSER_ALL_FOR_NOW:
735
case AVAHI_BROWSER_CACHE_EXHAUSTED:
737
fprintf(stderr, "No Mandos server found, still searching...\n");
581
static void browse_callback(
582
AvahiSServiceBrowser *b,
583
AvahiIfIndex interface,
584
AvahiProtocol protocol,
585
AvahiBrowserEvent event,
589
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
592
AvahiServer *s = userdata;
593
assert(b); /* Spurious warning */
595
/* Called whenever a new services becomes available on the LAN or
596
is removed from the LAN */
600
case AVAHI_BROWSER_FAILURE:
602
fprintf(stderr, "(Browser) %s\n",
603
avahi_strerror(avahi_server_errno(server)));
604
avahi_simple_poll_quit(simple_poll);
607
case AVAHI_BROWSER_NEW:
608
/* We ignore the returned resolver object. In the callback
609
function we free it. If the server is terminated before
610
the callback function is called the server will free
611
the resolver for us. */
613
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
615
AVAHI_PROTO_INET6, 0,
616
resolve_callback, s)))
617
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
618
avahi_strerror(avahi_server_errno(s)));
621
case AVAHI_BROWSER_REMOVE:
624
case AVAHI_BROWSER_ALL_FOR_NOW:
625
case AVAHI_BROWSER_CACHE_EXHAUSTED:
743
/* Combines file name and path and returns the malloced new
744
string. some sane checks could/should be added */
745
static const char *combinepath(const char *first, const char *second){
746
size_t f_len = strlen(first);
747
size_t s_len = strlen(second);
748
char *tmp = malloc(f_len + s_len + 2);
630
/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */
631
const char *combinepath(const char *first, const char *second){
633
tmp = malloc(strlen(first) + strlen(second) + 2);
749
634
if (tmp == NULL){
753
memcpy(tmp, first, f_len); /* Spurious warning */
757
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
759
tmp[f_len + 1 + s_len] = '\0';
639
if (first[0] != '\0' and first[strlen(first) - 1] != '/'){
764
int main(int argc, char *argv[]){
647
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
648
AvahiServerConfig config;
765
649
AvahiSServiceBrowser *sb = NULL;
768
int exitcode = EXIT_SUCCESS;
769
const char *interface = "eth0";
770
struct ifreq network;
652
int returncode = EXIT_SUCCESS;
653
const char *interface = NULL;
654
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
774
655
char *connect_to = NULL;
775
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
776
const char *pubkeyfile = "pubkey.txt";
777
const char *seckeyfile = "seckey.txt";
778
mandos_context mc = { .simple_poll = NULL, .server = NULL,
779
.dh_bits = 1024, .priority = "SECURE256"};
780
bool gnutls_initalized = false;
783
struct argp_option options[] = {
784
{ .name = "debug", .key = 128,
785
.doc = "Debug mode", .group = 3 },
786
{ .name = "connect", .key = 'c',
788
.doc = "Connect directly to a sepcified mandos server",
790
{ .name = "interface", .key = 'i',
792
.doc = "Interface that Avahi will conntect through",
794
{ .name = "keydir", .key = 'd',
796
.doc = "Directory where the openpgp keyring is",
798
{ .name = "seckey", .key = 's',
800
.doc = "Secret openpgp key for gnutls authentication",
802
{ .name = "pubkey", .key = 'p',
804
.doc = "Public openpgp key for gnutls authentication",
806
{ .name = "dh-bits", .key = 129,
808
.doc = "dh-bits to use in gnutls communication",
810
{ .name = "priority", .key = 130,
812
.doc = "GNUTLS priority", .group = 1 },
817
error_t parse_opt (int key, char *arg,
818
struct argp_state *state) {
819
/* Get the INPUT argument from `argp_parse', which we know is
820
a pointer to our plugin list pointer. */
842
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
856
return ARGP_ERR_UNKNOWN;
861
struct argp argp = { .options = options, .parser = parse_opt,
863
.doc = "Mandos client -- Get and decrypt"
864
" passwords from mandos server" };
865
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
866
if (ret == ARGP_ERR_UNKNOWN){
867
fprintf(stderr, "Unknown error while parsing arguments\n");
868
exitcode = EXIT_FAILURE;
873
pubkeyfile = combinepath(keydir, pubkeyfile);
874
if (pubkeyfile == NULL){
875
perror("combinepath");
876
exitcode = EXIT_FAILURE;
880
seckeyfile = combinepath(keydir, seckeyfile);
881
if (seckeyfile == NULL){
882
perror("combinepath");
883
exitcode = EXIT_FAILURE;
887
ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
889
fprintf(stderr, "init_gnutls_global failed\n");
890
exitcode = EXIT_FAILURE;
893
gnutls_initalized = true;
896
/* If the interface is down, bring it up */
898
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
901
exitcode = EXIT_FAILURE;
904
strcpy(network.ifr_name, interface); /* Spurious warning */
905
ret = ioctl(sd, SIOCGIFFLAGS, &network);
907
perror("ioctl SIOCGIFFLAGS");
908
exitcode = EXIT_FAILURE;
911
if((network.ifr_flags & IFF_UP) == 0){
912
network.ifr_flags |= IFF_UP;
913
ret = ioctl(sd, SIOCSIFFLAGS, &network);
915
perror("ioctl SIOCSIFFLAGS");
916
exitcode = EXIT_FAILURE;
936
if_index = (AvahiIfIndex) if_nametoindex(interface);
938
fprintf(stderr, "No such interface: \"%s\"\n", interface);
658
static struct option long_options[] = {
659
{"debug", no_argument, (int *)&debug, 1},
660
{"connect", required_argument, 0, 'C'},
661
{"interface", required_argument, 0, 'i'},
662
{"certdir", required_argument, 0, 'd'},
663
{"certkey", required_argument, 0, 'c'},
664
{"certfile", required_argument, 0, 'k'},
667
int option_index = 0;
668
ret = getopt_long (argc, argv, "i:", long_options,
698
certfile = combinepath(certdir, certfile);
699
if (certfile == NULL){
703
if(interface != NULL){
704
if_index = (AvahiIfIndex) if_nametoindex(interface);
706
fprintf(stderr, "No such interface: \"%s\"\n", interface);
942
711
if(connect_to != NULL){
945
714
char *address = strrchr(connect_to, ':');
946
715
if(address == NULL){
947
716
fprintf(stderr, "No colon in address\n");
948
exitcode = EXIT_FAILURE;
952
720
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
954
722
perror("Bad port number");
955
exitcode = EXIT_FAILURE;
959
726
address = connect_to;
960
ret = start_mandos_communication(address, port, if_index, &mc);
727
ret = start_mandos_communication(address, port, if_index);
962
exitcode = EXIT_FAILURE;
964
exitcode = EXIT_SUCCESS;
735
certkey = combinepath(certdir, certkey);
736
if (certkey == NULL){
970
741
avahi_set_log_function(empty_log);
973
/* Initialize the pseudo-RNG for Avahi */
744
/* Initialize the psuedo-RNG */
974
745
srand((unsigned int) time(NULL));
976
/* Allocate main Avahi loop object */
977
mc.simple_poll = avahi_simple_poll_new();
978
if (mc.simple_poll == NULL) {
979
fprintf(stderr, "Avahi: Failed to create simple poll"
981
exitcode = EXIT_FAILURE;
986
AvahiServerConfig config;
987
/* Do not publish any local Zeroconf records */
988
avahi_server_config_init(&config);
989
config.publish_hinfo = 0;
990
config.publish_addresses = 0;
991
config.publish_workstation = 0;
992
config.publish_domain = 0;
994
/* Allocate a new server */
995
mc.server = avahi_server_new(avahi_simple_poll_get
996
(mc.simple_poll), &config, NULL,
999
/* Free the Avahi configuration data */
1000
avahi_server_config_free(&config);
1003
/* Check if creating the Avahi server object succeeded */
1004
if (mc.server == NULL) {
1005
fprintf(stderr, "Failed to create Avahi server: %s\n",
747
/* Allocate main loop object */
748
if (!(simple_poll = avahi_simple_poll_new())) {
749
fprintf(stderr, "Failed to create simple poll object.\n");
754
/* Do not publish any local records */
755
avahi_server_config_init(&config);
756
config.publish_hinfo = 0;
757
config.publish_addresses = 0;
758
config.publish_workstation = 0;
759
config.publish_domain = 0;
761
/* Allocate a new server */
762
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
763
&config, NULL, NULL, &error);
765
/* Free the configuration data */
766
avahi_server_config_free(&config);
768
/* Check if creating the server object succeeded */
770
fprintf(stderr, "Failed to create server: %s\n",
1006
771
avahi_strerror(error));
1007
exitcode = EXIT_FAILURE;
772
returncode = EXIT_FAILURE;
1011
/* Create the Avahi service browser */
1012
sb = avahi_s_service_browser_new(mc.server, if_index,
776
/* Create the service browser */
777
sb = avahi_s_service_browser_new(server, if_index,
1013
778
AVAHI_PROTO_INET6,
1014
779
"_mandos._tcp", NULL, 0,
1015
browse_callback, &mc);
780
browse_callback, server);
1017
782
fprintf(stderr, "Failed to create service browser: %s\n",
1018
avahi_strerror(avahi_server_errno(mc.server)));
1019
exitcode = EXIT_FAILURE;
783
avahi_strerror(avahi_server_errno(server)));
784
returncode = EXIT_FAILURE;
1023
788
/* Run the main loop */
1026
fprintf(stderr, "Starting Avahi loop search\n");
791
fprintf(stderr, "Starting avahi loop search\n");
1029
avahi_simple_poll_loop(mc.simple_poll);
794
avahi_simple_poll_loop(simple_poll);
1034
799
fprintf(stderr, "%s exiting\n", argv[0]);
1037
802
/* Cleanup things */
1039
804
avahi_s_service_browser_free(sb);
1041
if (mc.server != NULL)
1042
avahi_server_free(mc.server);
1044
if (mc.simple_poll != NULL)
1045
avahi_simple_poll_free(mc.simple_poll);
1049
if (gnutls_initalized){
1050
gnutls_certificate_free_credentials(mc.cred);
1051
gnutls_global_deinit ();
807
avahi_server_free(server);
810
avahi_simple_poll_free(simple_poll);