25
25
* along with this program. If not, see
26
26
* <http://www.gnu.org/licenses/>.
28
* Contact the authors at <mandos@fukt.bsnet.se>.
28
* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
29
* <https://www.fukt.bsnet.se/~teddy/>.
31
/* Needed by GPGME, specifically gpgme_data_seek() */
32
#define _FORTIFY_SOURCE 2
32
34
#define _LARGEFILE_SOURCE
33
35
#define _FILE_OFFSET_BITS 64
35
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
37
#include <stdio.h> /* fprintf(), stderr, fwrite(), stdout, ferror() */
38
#include <stdint.h> /* uint16_t, uint32_t */
39
#include <stddef.h> /* NULL, size_t, ssize_t */
40
#include <stdlib.h> /* free() */
41
#include <stdbool.h> /* bool, true */
42
#include <string.h> /* memset(), strcmp(), strlen, strerror() */
43
#include <sys/ioctl.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
45
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
46
sockaddr_in6, PF_INET6, SOCK_STREAM, INET6_ADDRSTRLEN */
47
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
48
struct in6_addr, inet_pton(),
50
38
#include <assert.h>
51
#include <errno.h> /* perror() */
53
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
54
SIOCSIFFLAGS, if_indextoname(),
55
if_nametoindex(), IF_NAMESIZE */
56
#include <unistd.h> /* close(), SEEK_SET, off_t, write()*/
57
#include <netinet/in.h>
58
#include <arpa/inet.h> /* inet_pton(), htons */
59
#include <iso646.h> /* not */
60
#include <argp.h> /* struct argp_option,
61
struct argp_state, struct argp,
41
#include <net/if.h> /* if_nametoindex */
65
#include <avahi-core/core.h> /* AvahiSimplePoll, AvahiServer,
43
#include <avahi-core/core.h>
67
44
#include <avahi-core/lookup.h>
68
#include <avahi-core/log.h> /* AvahiLogLevel */
45
#include <avahi-core/log.h>
69
46
#include <avahi-common/simple-watch.h>
70
47
#include <avahi-common/malloc.h>
71
48
#include <avahi-common/error.h>
74
#include <gnutls/gnutls.h> /* gnutls_certificate_credentials_t,
78
gnutls_global_set_log_level(),
79
gnutls_global_set_log_function(),
80
gnutls_certificate_allocate_credentials(),
81
gnutls_global_deinit(),
82
gnutls_dh_params_init(),
83
gnutls_dh_params_generate(),
84
gnutls_certificate_set_dh_params(),
85
gnutls_certificate_free_credentials(),
86
gnutls_session_t, gnutls_init(),
87
gnutls_priority_set_direct(),
89
gnutls_credentials_set(),
90
gnutls_certificate_server_set_request(),
91
gnutls_dh_set_prime_bits(),
92
gnutls_transport_set_ptr(),
93
gnutls_transport_ptr_t,
96
gnutls_perror(), gnutls_bye(),
97
init_gnutls_session(),
99
GNUTLS_CRD_CERTIFICATE,
101
GNUTLS_E_INTERRUPTED,
103
GNUTLS_E_REHANDSHAKE,
105
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
106
GNUTLS_OPENPGP_FMT_BASE64 */
109
#include <gpgme.h> /* gpgme_data_t, gpgme_ctx_t,
110
gpgme_error_t, gpgme_engine_info_t,
111
gpgme_check_version(),
112
gpgme_engine_check_version(),
115
gpgme_get_engine_info(),
116
gpgme_set_engine_info(),
117
gpgme_data_new_from_mem(),
118
gpgme_data_new(), gpgme_new(),
120
gpgme_decrypt_result_t,
121
gpgme_op_decrypt_result(),
123
gpgme_pubkey_algo_name(),
127
GPGME_PROTOCOL_OpenPGP,
129
GPG_ERR_NO_SECKEY, */
51
#include <sys/types.h> /* socket(), inet_pton() */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton() */
54
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
55
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
57
#include <unistd.h> /* close() */
58
#include <netinet/in.h>
59
#include <stdbool.h> /* true */
60
#include <string.h> /* memset */
61
#include <arpa/inet.h> /* inet_pton() */
62
#include <iso646.h> /* not */
65
#include <errno.h> /* perror() */
131
71
#define BUFFER_SIZE 256
74
const char *certdir = "/conf/conf.d/cryptkeyreq/";
75
const char *certfile = "openpgp-client.txt";
76
const char *certkey = "openpgp-client-key.txt";
133
78
bool debug = false;
134
static const char *keydir = "/conf/conf.d/mandos";
135
static const char mandos_protocol_version[] = "1";
136
const char *argp_program_version = "mandosclient 0.9";
137
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
139
/* Used for passing in values through the Avahi callback functions */
141
AvahiSimplePoll *simple_poll;
81
gnutls_session_t session;
143
82
gnutls_certificate_credentials_t cred;
144
unsigned int dh_bits;
145
83
gnutls_dh_params_t dh_params;
146
const char *priority;
150
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
151
* "buffer_capacity" is how much is currently allocated,
152
* "buffer_length" is how much is already used.
154
size_t adjustbuffer(char **buffer, size_t buffer_length,
155
size_t buffer_capacity){
156
if (buffer_length + BUFFER_SIZE > buffer_capacity){
157
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
161
buffer_capacity += BUFFER_SIZE;
163
return buffer_capacity;
167
* Decrypt OpenPGP data using keyrings in HOMEDIR.
168
* Returns -1 on error
170
static ssize_t pgp_packet_decrypt (const char *cryptotext,
173
const char *homedir){
87
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet, const char *homedir){
174
89
gpgme_data_t dh_crypto, dh_plain;
178
size_t plaintext_capacity = 0;
179
ssize_t plaintext_length = 0;
93
ssize_t new_packet_capacity = 0;
94
ssize_t new_packet_length = 0;
180
95
gpgme_engine_info_t engine_info;
183
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
98
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
358
261
if ((ret = gnutls_global_init ())
359
262
!= GNUTLS_E_SUCCESS) {
360
fprintf (stderr, "GnuTLS global_init: %s\n",
361
safer_gnutls_strerror(ret));
263
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
366
/* "Use a log level over 10 to enable all debugging options."
369
268
gnutls_global_set_log_level(11);
370
269
gnutls_global_set_log_function(debuggnutls);
373
/* OpenPGP credentials */
374
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
272
/* openpgp credentials */
273
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
375
274
!= GNUTLS_E_SUCCESS) {
376
fprintf (stderr, "GnuTLS memory error: %s\n",
275
fprintf (stderr, "memory error: %s\n",
377
276
safer_gnutls_strerror(ret));
378
gnutls_global_deinit ();
383
281
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
384
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
282
" and keyfile %s as GnuTLS credentials\n", certfile,
388
286
ret = gnutls_certificate_set_openpgp_key_file
389
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
287
(es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
390
288
if (ret != GNUTLS_E_SUCCESS) {
392
"Error[%d] while reading the OpenPGP key pair ('%s',"
393
" '%s')\n", ret, pubkeyfile, seckeyfile);
394
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",
395
294
safer_gnutls_strerror(ret));
399
/* GnuTLS server initialization */
400
ret = gnutls_dh_params_init(&mc->dh_params);
401
if (ret != GNUTLS_E_SUCCESS) {
402
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
403
" %s\n", safer_gnutls_strerror(ret));
406
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
407
if (ret != GNUTLS_E_SUCCESS) {
408
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
409
safer_gnutls_strerror(ret));
413
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
419
gnutls_certificate_free_credentials(mc->cred);
420
gnutls_global_deinit();
425
static int init_gnutls_session(mandos_context *mc,
426
gnutls_session_t *session){
428
/* GnuTLS session creation */
429
ret = gnutls_init(session, GNUTLS_SERVER);
430
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){
431
318
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
432
319
safer_gnutls_strerror(ret));
437
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
438
if (ret != GNUTLS_E_SUCCESS) {
439
fprintf(stderr, "Syntax error at: %s\n", err);
440
fprintf(stderr, "GnuTLS error: %s\n",
441
safer_gnutls_strerror(ret));
442
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));
447
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
449
if (ret != GNUTLS_E_SUCCESS) {
450
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",
451
334
safer_gnutls_strerror(ret));
452
gnutls_deinit (*session);
456
338
/* ignore client certificate if any. */
457
gnutls_certificate_server_set_request (*session,
339
gnutls_certificate_server_set_request (es->session,
458
340
GNUTLS_CERT_IGNORE);
460
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
342
gnutls_dh_set_prime_bits (es->session, DH_BITS);
465
/* Avahi log function callback */
466
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
467
__attribute__((unused)) const char *txt){}
347
void empty_log(__attribute__((unused)) AvahiLogLevel level,
348
__attribute__((unused)) const char *txt){}
469
/* Called when a Mandos server is found */
470
static int start_mandos_communication(const char *ip, uint16_t port,
471
AvahiIfIndex if_index,
350
int start_mandos_communication(const char *ip, uint16_t port,
351
unsigned int if_index){
474
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
353
struct sockaddr_in6 to;
354
encrypted_session es;
475
355
char *buffer = NULL;
476
356
char *decrypted_buffer;
477
357
size_t buffer_length = 0;
478
358
size_t buffer_capacity = 0;
479
359
ssize_t decrypted_buffer_size;
482
362
char interface[IF_NAMESIZE];
483
gnutls_session_t session;
485
ret = init_gnutls_session (mc, &session);
491
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
365
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
495
368
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
497
370
perror("socket");
502
if(if_indextoname((unsigned int)if_index, interface) == NULL){
374
if(if_indextoname(if_index, interface) == NULL){
503
376
perror("if_indextoname");
506
382
fprintf(stderr, "Binding to interface %s\n", interface);
509
385
memset(&to,0,sizeof(to)); /* Spurious warning */
510
to.in6.sin6_family = AF_INET6;
511
/* It would be nice to have a way to detect if we were passed an
512
IPv4 address here. Now we assume an IPv6 address. */
513
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
386
to.sin6_family = AF_INET6;
387
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
515
389
perror("inet_pton");
519
393
fprintf(stderr, "Bad address: %s\n", ip);
522
to.in6.sin6_port = htons(port); /* Spurious warning */
396
to.sin6_port = htons(port); /* Spurious warning */
524
to.in6.sin6_scope_id = (uint32_t)if_index;
398
to.sin6_scope_id = (uint32_t)if_index;
527
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
528
char addrstr[INET6_ADDRSTRLEN] = "";
529
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
530
sizeof(addrstr)) == NULL){
533
if(strcmp(addrstr, ip) != 0){
534
fprintf(stderr, "Canonical address form: %s\n", addrstr);
401
fprintf(stderr, "Connection to: %s\n", ip);
539
ret = connect(tcp_sd, &to.in, sizeof(to));
404
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
541
406
perror("connect");
545
const char *out = mandos_protocol_version;
548
size_t out_size = strlen(out);
549
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
550
out_size - written));
556
written += (size_t)ret;
557
if(written < out_size){
560
if (out == mandos_protocol_version){
410
ret = initgnutls (&es);
416
gnutls_transport_set_ptr (es.session,
417
(gnutls_transport_ptr_t) tcp_sd);
570
420
fprintf(stderr, "Establishing TLS session with %s\n", ip);
573
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
575
ret = gnutls_handshake (session);
423
ret = gnutls_handshake (es.session);
577
425
if (ret != GNUTLS_E_SUCCESS){
579
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
427
fprintf(stderr, "\n*** Handshake failed ***\n");
580
428
gnutls_perror (ret);
586
/* Read OpenPGP packet that contains the wanted password */
434
//Retrieve OpenPGP packet that contains the wanted password
589
437
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
717
570
avahi_s_service_resolver_free(r);
720
static void browse_callback( AvahiSServiceBrowser *b,
721
AvahiIfIndex interface,
722
AvahiProtocol protocol,
723
AvahiBrowserEvent event,
727
AVAHI_GCC_UNUSED AvahiLookupResultFlags
730
mandos_context *mc = userdata;
731
assert(b); /* Spurious warning */
733
/* Called whenever a new services becomes available on the LAN or
734
is removed from the LAN */
738
case AVAHI_BROWSER_FAILURE:
740
fprintf(stderr, "(Avahi browser) %s\n",
741
avahi_strerror(avahi_server_errno(mc->server)));
742
avahi_simple_poll_quit(mc->simple_poll);
745
case AVAHI_BROWSER_NEW:
746
/* We ignore the returned Avahi resolver object. In the callback
747
function we free it. If the Avahi server is terminated before
748
the callback function is called the Avahi server will free the
751
if (!(avahi_s_service_resolver_new(mc->server, interface,
752
protocol, name, type, domain,
753
AVAHI_PROTO_INET6, 0,
754
resolve_callback, mc)))
755
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
756
name, avahi_strerror(avahi_server_errno(mc->server)));
759
case AVAHI_BROWSER_REMOVE:
762
case AVAHI_BROWSER_ALL_FOR_NOW:
763
case AVAHI_BROWSER_CACHE_EXHAUSTED:
765
fprintf(stderr, "No Mandos server found, still searching...\n");
573
static void browse_callback(
574
AvahiSServiceBrowser *b,
575
AvahiIfIndex interface,
576
AvahiProtocol protocol,
577
AvahiBrowserEvent event,
581
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
584
AvahiServer *s = userdata;
585
assert(b); /* Spurious warning */
587
/* Called whenever a new services becomes available on the LAN or
588
is removed from the LAN */
592
case AVAHI_BROWSER_FAILURE:
594
fprintf(stderr, "(Browser) %s\n",
595
avahi_strerror(avahi_server_errno(server)));
596
avahi_simple_poll_quit(simple_poll);
599
case AVAHI_BROWSER_NEW:
600
/* We ignore the returned resolver object. In the callback
601
function we free it. If the server is terminated before
602
the callback function is called the server will free
603
the resolver for us. */
605
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
607
AVAHI_PROTO_INET6, 0,
608
resolve_callback, s)))
609
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
610
avahi_strerror(avahi_server_errno(s)));
613
case AVAHI_BROWSER_REMOVE:
616
case AVAHI_BROWSER_ALL_FOR_NOW:
617
case AVAHI_BROWSER_CACHE_EXHAUSTED:
771
/* Combines file name and path and returns the malloced new
772
string. some sane checks could/should be added */
773
static const char *combinepath(const char *first, const char *second){
774
size_t f_len = strlen(first);
775
size_t s_len = strlen(second);
776
char *tmp = malloc(f_len + s_len + 2);
622
/* combinds two strings and returns the malloced new string. som sane checks could/should be added */
623
const char *combinestrings(const char *first, const char *second){
625
tmp = malloc(strlen(first) + strlen(second));
777
626
if (tmp == NULL){
781
memcpy(tmp, first, f_len); /* Spurious warning */
785
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
787
tmp[f_len + 1 + s_len] = '\0';
792
int main(int argc, char *argv[]){
636
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
637
AvahiServerConfig config;
793
638
AvahiSServiceBrowser *sb = NULL;
796
int exitcode = EXIT_SUCCESS;
641
int returncode = EXIT_SUCCESS;
797
642
const char *interface = "eth0";
798
struct ifreq network;
802
char *connect_to = NULL;
803
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
804
const char *pubkeyfile = "pubkey.txt";
805
const char *seckeyfile = "seckey.txt";
806
mandos_context mc = { .simple_poll = NULL, .server = NULL,
807
.dh_bits = 1024, .priority = "SECURE256"};
808
bool gnutls_initalized = false;
811
struct argp_option options[] = {
812
{ .name = "debug", .key = 128,
813
.doc = "Debug mode", .group = 3 },
814
{ .name = "connect", .key = 'c',
816
.doc = "Connect directly to a sepcified mandos server",
818
{ .name = "interface", .key = 'i',
820
.doc = "Interface that Avahi will conntect through",
822
{ .name = "keydir", .key = 'd',
824
.doc = "Directory where the openpgp keyring is",
826
{ .name = "seckey", .key = 's',
828
.doc = "Secret openpgp key for gnutls authentication",
830
{ .name = "pubkey", .key = 'p',
832
.doc = "Public openpgp key for gnutls authentication",
834
{ .name = "dh-bits", .key = 129,
836
.doc = "dh-bits to use in gnutls communication",
838
{ .name = "priority", .key = 130,
840
.doc = "GNUTLS priority", .group = 1 },
845
error_t parse_opt (int key, char *arg,
846
struct argp_state *state) {
847
/* Get the INPUT argument from `argp_parse', which we know is
848
a pointer to our plugin list pointer. */
870
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
885
return ARGP_ERR_UNKNOWN;
890
struct argp argp = { .options = options, .parser = parse_opt,
892
.doc = "Mandos client -- Get and decrypt"
893
" passwords from mandos server" };
894
argp_parse (&argp, argc, argv, 0, 0, NULL);
897
pubkeyfile = combinepath(keydir, pubkeyfile);
898
if (pubkeyfile == NULL){
899
perror("combinepath");
900
exitcode = EXIT_FAILURE;
904
seckeyfile = combinepath(keydir, seckeyfile);
905
if (seckeyfile == NULL){
906
perror("combinepath");
910
ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
912
fprintf(stderr, "init_gnutls_global\n");
915
gnutls_initalized = true;
931
if_index = (AvahiIfIndex) if_nametoindex(interface);
933
fprintf(stderr, "No such interface: \"%s\"\n", interface);
937
if(connect_to != NULL){
938
/* Connect directly, do not use Zeroconf */
939
/* (Mainly meant for debugging) */
940
char *address = strrchr(connect_to, ':');
942
fprintf(stderr, "No colon in address\n");
943
exitcode = EXIT_FAILURE;
947
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
949
perror("Bad port number");
950
exitcode = EXIT_FAILURE;
954
address = connect_to;
955
ret = start_mandos_communication(address, port, if_index, &mc);
957
exitcode = EXIT_FAILURE;
959
exitcode = EXIT_SUCCESS;
964
/* If the interface is down, bring it up */
966
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
969
exitcode = EXIT_FAILURE;
972
strcpy(network.ifr_name, interface); /* Spurious warning */
973
ret = ioctl(sd, SIOCGIFFLAGS, &network);
975
perror("ioctl SIOCGIFFLAGS");
976
exitcode = EXIT_FAILURE;
979
if((network.ifr_flags & IFF_UP) == 0){
980
network.ifr_flags |= IFF_UP;
981
ret = ioctl(sd, SIOCSIFFLAGS, &network);
983
perror("ioctl SIOCSIFFLAGS");
984
exitcode = EXIT_FAILURE;
645
static struct option long_options[] = {
646
{"debug", no_argument, (int *)&debug, 1},
647
{"interface", required_argument, 0, 'i'},
648
{"certdir", required_argument, 0, 'd'},
649
{"certkey", required_argument, 0, 'c'},
650
{"certfile", required_argument, 0, 'k'},
653
int option_index = 0;
654
ret = getopt_long (argc, argv, "i:", long_options,
681
certfile = combinestrings(certdir, certfile);
682
if (certfile == NULL){
686
certkey = combinestrings(certdir, certkey);
687
if (certkey == NULL){
992
692
avahi_set_log_function(empty_log);
995
/* Initialize the pseudo-RNG for Avahi */
695
/* Initialize the psuedo-RNG */
996
696
srand((unsigned int) time(NULL));
998
/* Allocate main Avahi loop object */
999
mc.simple_poll = avahi_simple_poll_new();
1000
if (mc.simple_poll == NULL) {
1001
fprintf(stderr, "Avahi: Failed to create simple poll"
1003
exitcode = EXIT_FAILURE;
1008
AvahiServerConfig config;
1009
/* Do not publish any local Zeroconf records */
1010
avahi_server_config_init(&config);
1011
config.publish_hinfo = 0;
1012
config.publish_addresses = 0;
1013
config.publish_workstation = 0;
1014
config.publish_domain = 0;
1016
/* Allocate a new server */
1017
mc.server = avahi_server_new(avahi_simple_poll_get
1018
(mc.simple_poll), &config, NULL,
1021
/* Free the Avahi configuration data */
1022
avahi_server_config_free(&config);
1025
/* Check if creating the Avahi server object succeeded */
1026
if (mc.server == NULL) {
1027
fprintf(stderr, "Failed to create Avahi server: %s\n",
698
/* Allocate main loop object */
699
if (!(simple_poll = avahi_simple_poll_new())) {
700
fprintf(stderr, "Failed to create simple poll object.\n");
705
/* Do not publish any local records */
706
avahi_server_config_init(&config);
707
config.publish_hinfo = 0;
708
config.publish_addresses = 0;
709
config.publish_workstation = 0;
710
config.publish_domain = 0;
712
/* Allocate a new server */
713
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
714
&config, NULL, NULL, &error);
716
/* Free the configuration data */
717
avahi_server_config_free(&config);
719
/* Check if creating the server object succeeded */
721
fprintf(stderr, "Failed to create server: %s\n",
1028
722
avahi_strerror(error));
1029
exitcode = EXIT_FAILURE;
723
returncode = EXIT_FAILURE;
1033
/* Create the Avahi service browser */
1034
sb = avahi_s_service_browser_new(mc.server, if_index,
727
/* Create the service browser */
728
sb = avahi_s_service_browser_new(server,
730
if_nametoindex(interface),
1035
731
AVAHI_PROTO_INET6,
1036
732
"_mandos._tcp", NULL, 0,
1037
browse_callback, &mc);
733
browse_callback, server);
1039
735
fprintf(stderr, "Failed to create service browser: %s\n",
1040
avahi_strerror(avahi_server_errno(mc.server)));
1041
exitcode = EXIT_FAILURE;
736
avahi_strerror(avahi_server_errno(server)));
737
returncode = EXIT_FAILURE;
1045
741
/* Run the main loop */
1048
fprintf(stderr, "Starting Avahi loop search\n");
744
fprintf(stderr, "Starting avahi loop search\n");
1051
avahi_simple_poll_loop(mc.simple_poll);
747
avahi_simple_poll_loop(simple_poll);
1056
752
fprintf(stderr, "%s exiting\n", argv[0]);
1059
755
/* Cleanup things */
1061
757
avahi_s_service_browser_free(sb);
1063
if (mc.server != NULL)
1064
avahi_server_free(mc.server);
1066
if (mc.simple_poll != NULL)
1067
avahi_simple_poll_free(mc.simple_poll);
1071
if (gnutls_initalized){
1072
gnutls_certificate_free_credentials (mc.cred);
1073
gnutls_global_deinit ();
760
avahi_server_free(server);
763
avahi_simple_poll_free(simple_poll);