60
64
#include <string.h> /* memset */
61
65
#include <arpa/inet.h> /* inet_pton() */
62
66
#include <iso646.h> /* not */
67
#include <net/if.h> /* IF_NAMESIZE */
68
#include <argp.h> /* struct argp_option,
69
struct argp_state, struct argp,
65
72
#include <errno.h> /* perror() */
71
75
#define BUFFER_SIZE 256
74
static const char *certdir = "/conf/conf.d/mandos";
75
static const char *certfile = "openpgp-client.txt";
76
static const char *certkey = "openpgp-client-key.txt";
78
77
bool debug = false;
78
static const char *keydir = "/conf/conf.d/mandos";
79
const char *argp_program_version = "mandosclient 0.9";
80
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
81
static const char mandos_protocol_version[] = "1";
83
/* Used for passing in values through the Avahi callback functions */
81
gnutls_session_t session;
85
AvahiSimplePoll *simple_poll;
82
87
gnutls_certificate_credentials_t cred;
83
89
gnutls_dh_params_t dh_params;
87
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
93
/* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
94
* "buffer_capacity" is how much is currently allocated,
95
* "buffer_length" is how much is already used. */
96
size_t adjustbuffer(char **buffer, size_t buffer_length,
97
size_t buffer_capacity){
98
if (buffer_length + BUFFER_SIZE > buffer_capacity){
99
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
103
buffer_capacity += BUFFER_SIZE;
105
return buffer_capacity;
109
* Decrypt OpenPGP data using keyrings in HOMEDIR.
110
* Returns -1 on error
112
static ssize_t pgp_packet_decrypt (const char *cryptotext,
89
115
const char *homedir){
90
116
gpgme_data_t dh_crypto, dh_plain;
94
ssize_t new_packet_capacity = 0;
95
ssize_t new_packet_length = 0;
120
size_t plaintext_capacity = 0;
121
ssize_t plaintext_length = 0;
96
122
gpgme_engine_info_t engine_info;
99
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
125
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
197
/* Delete the GPGME FILE pointer cryptotext data buffer */
198
gpgme_data_release(dh_crypto);
200
227
/* Seek back to the beginning of the GPGME plaintext data buffer */
201
228
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
202
229
perror("pgpme_data_seek");
230
plaintext_length = -1;
207
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
208
*new_packet = realloc(*new_packet,
209
(unsigned int)new_packet_capacity
211
if (*new_packet == NULL){
215
new_packet_capacity += BUFFER_SIZE;
236
plaintext_capacity = adjustbuffer(plaintext,
237
(size_t)plaintext_length,
239
if (plaintext_capacity == 0){
240
perror("adjustbuffer");
241
plaintext_length = -1;
218
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
245
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
220
247
/* Print the data, if any */
225
253
perror("gpgme_data_read");
254
plaintext_length = -1;
228
new_packet_length += ret;
257
plaintext_length += ret;
231
/* FIXME: check characters before printing to screen so to not print
232
terminal control characters */
234
/* fprintf(stderr, "decrypted password is: "); */
235
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
236
/* fprintf(stderr, "\n"); */
261
fprintf(stderr, "Decrypted password is: ");
262
for(ssize_t i = 0; i < plaintext_length; i++){
263
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
265
fprintf(stderr, "\n");
270
/* Delete the GPGME cryptotext data buffer */
271
gpgme_data_release(dh_crypto);
239
273
/* Delete the GPGME plaintext data buffer */
240
274
gpgme_data_release(dh_plain);
241
return new_packet_length;
275
return plaintext_length;
244
278
static const char * safer_gnutls_strerror (int value) {
264
300
if ((ret = gnutls_global_init ())
265
301
!= GNUTLS_E_SUCCESS) {
266
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
302
fprintf (stderr, "GnuTLS global_init: %s\n",
303
safer_gnutls_strerror(ret));
308
/* "Use a log level over 10 to enable all debugging options."
271
311
gnutls_global_set_log_level(11);
272
312
gnutls_global_set_log_function(debuggnutls);
275
/* openpgp credentials */
276
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
315
/* OpenPGP credentials */
316
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
277
317
!= GNUTLS_E_SUCCESS) {
278
fprintf (stderr, "memory error: %s\n",
318
fprintf (stderr, "GnuTLS memory error: %s\n",
279
319
safer_gnutls_strerror(ret));
284
324
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
285
" and keyfile %s as GnuTLS credentials\n", certfile,
325
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
289
329
ret = gnutls_certificate_set_openpgp_key_file
290
(es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
330
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
291
331
if (ret != GNUTLS_E_SUCCESS) {
293
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
295
ret, certfile, certkey);
296
fprintf(stdout, "The Error is: %s\n",
333
"Error[%d] while reading the OpenPGP key pair ('%s',"
334
" '%s')\n", ret, pubkeyfile, seckeyfile);
335
fprintf(stdout, "The GnuTLS error is: %s\n",
297
336
safer_gnutls_strerror(ret));
301
//GnuTLS server initialization
302
if ((ret = gnutls_dh_params_init (&es->dh_params))
303
!= GNUTLS_E_SUCCESS) {
304
fprintf (stderr, "Error in dh parameter initialization: %s\n",
305
safer_gnutls_strerror(ret));
309
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
310
!= GNUTLS_E_SUCCESS) {
311
fprintf (stderr, "Error in prime generation: %s\n",
312
safer_gnutls_strerror(ret));
316
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
318
// GnuTLS session creation
319
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
320
!= GNUTLS_E_SUCCESS){
340
/* GnuTLS server initialization */
341
ret = gnutls_dh_params_init(&mc->dh_params);
342
if (ret != GNUTLS_E_SUCCESS) {
343
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
344
" %s\n", safer_gnutls_strerror(ret));
347
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
348
if (ret != GNUTLS_E_SUCCESS) {
349
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
350
safer_gnutls_strerror(ret));
354
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
359
static int init_gnutls_session(mandos_context *mc,
360
gnutls_session_t *session){
362
/* GnuTLS session creation */
363
ret = gnutls_init(session, GNUTLS_SERVER);
364
if (ret != GNUTLS_E_SUCCESS){
321
365
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
322
366
safer_gnutls_strerror(ret));
325
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
326
!= GNUTLS_E_SUCCESS) {
327
fprintf(stderr, "Syntax error at: %s\n", err);
328
fprintf(stderr, "GnuTLS error: %s\n",
329
safer_gnutls_strerror(ret));
371
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
372
if (ret != GNUTLS_E_SUCCESS) {
373
fprintf(stderr, "Syntax error at: %s\n", err);
374
fprintf(stderr, "GnuTLS error: %s\n",
375
safer_gnutls_strerror(ret));
333
if ((ret = gnutls_credentials_set
334
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
335
!= GNUTLS_E_SUCCESS) {
336
fprintf(stderr, "Error setting a credentials set: %s\n",
380
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
382
if (ret != GNUTLS_E_SUCCESS) {
383
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
337
384
safer_gnutls_strerror(ret));
341
388
/* ignore client certificate if any. */
342
gnutls_certificate_server_set_request (es->session,
389
gnutls_certificate_server_set_request (*session,
343
390
GNUTLS_CERT_IGNORE);
345
gnutls_dh_set_prime_bits (es->session, DH_BITS);
392
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
397
/* Avahi log function callback */
350
398
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
351
399
__attribute__((unused)) const char *txt){}
401
/* Called when a Mandos server is found */
353
402
static int start_mandos_communication(const char *ip, uint16_t port,
354
AvahiIfIndex if_index){
403
AvahiIfIndex if_index,
356
struct sockaddr_in6 to;
357
encrypted_session es;
406
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
358
407
char *buffer = NULL;
359
408
char *decrypted_buffer;
360
409
size_t buffer_length = 0;
361
410
size_t buffer_capacity = 0;
362
411
ssize_t decrypted_buffer_size;
365
414
char interface[IF_NAMESIZE];
415
gnutls_session_t session;
417
ret = init_gnutls_session (mc, &session);
368
423
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
379
434
if(if_indextoname((unsigned int)if_index, interface) == NULL){
381
perror("if_indextoname");
435
perror("if_indextoname");
386
438
fprintf(stderr, "Binding to interface %s\n", interface);
389
441
memset(&to,0,sizeof(to)); /* Spurious warning */
390
to.sin6_family = AF_INET6;
391
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
442
to.in6.sin6_family = AF_INET6;
443
/* It would be nice to have a way to detect if we were passed an
444
IPv4 address here. Now we assume an IPv6 address. */
445
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
393
447
perror("inet_pton");
397
451
fprintf(stderr, "Bad address: %s\n", ip);
400
to.sin6_port = htons(port); /* Spurious warning */
454
to.in6.sin6_port = htons(port); /* Spurious warning */
402
to.sin6_scope_id = (uint32_t)if_index;
456
to.in6.sin6_scope_id = (uint32_t)if_index;
405
459
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
406
/* char addrstr[INET6_ADDRSTRLEN]; */
407
/* if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr, */
408
/* sizeof(addrstr)) == NULL){ */
409
/* perror("inet_ntop"); */
411
/* fprintf(stderr, "Really connecting to: %s, port %d\n", */
412
/* addrstr, ntohs(to.sin6_port)); */
460
char addrstr[INET6_ADDRSTRLEN] = "";
461
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
462
sizeof(addrstr)) == NULL){
465
if(strcmp(addrstr, ip) != 0){
466
fprintf(stderr, "Canonical address form: %s\n", addrstr);
416
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
471
ret = connect(tcp_sd, &to.in, sizeof(to));
418
473
perror("connect");
422
ret = initgnutls (&es);
477
const char *out = mandos_protocol_version;
480
size_t out_size = strlen(out);
481
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
482
out_size - written));
488
written += (size_t)ret;
489
if(written < out_size){
492
if (out == mandos_protocol_version){
428
gnutls_transport_set_ptr (es.session,
429
(gnutls_transport_ptr_t) tcp_sd);
432
502
fprintf(stderr, "Establishing TLS session with %s\n", ip);
435
ret = gnutls_handshake (es.session);
505
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
507
ret = gnutls_handshake (session);
437
509
if (ret != GNUTLS_E_SUCCESS){
439
fprintf(stderr, "\n*** Handshake failed ***\n");
511
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
440
512
gnutls_perror (ret);
446
//Retrieve OpenPGP packet that contains the wanted password
518
/* Read OpenPGP packet that contains the wanted password */
449
521
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
471
542
case GNUTLS_E_AGAIN:
473
544
case GNUTLS_E_REHANDSHAKE:
474
ret = gnutls_handshake (es.session);
545
ret = gnutls_handshake (session);
476
fprintf(stderr, "\n*** Handshake failed ***\n");
547
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
477
548
gnutls_perror (ret);
483
554
fprintf(stderr, "Unknown error while reading data from"
484
" encrypted session with mandos server\n");
555
" encrypted session with Mandos server\n");
486
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
557
gnutls_bye (session, GNUTLS_SHUT_RDWR);
490
561
buffer_length += (size_t) ret;
566
fprintf(stderr, "Closing TLS session\n");
569
gnutls_bye (session, GNUTLS_SHUT_RDWR);
494
571
if (buffer_length > 0){
495
572
decrypted_buffer_size = pgp_packet_decrypt(buffer,
497
574
&decrypted_buffer,
499
576
if (decrypted_buffer_size >= 0){
500
578
while(written < (size_t) decrypted_buffer_size){
501
579
ret = (int)fwrite (decrypted_buffer + written, 1,
502
580
(size_t)decrypted_buffer_size - written,
523
fprintf(stderr, "Closing TLS session\n");
598
/* Shutdown procedure */
527
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
530
gnutls_deinit (es.session);
531
gnutls_certificate_free_credentials (es.cred);
603
gnutls_deinit (session);
604
gnutls_certificate_free_credentials (mc->cred);
532
605
gnutls_global_deinit ();
536
static AvahiSimplePoll *simple_poll = NULL;
537
static AvahiServer *server = NULL;
539
static void resolve_callback(
540
AvahiSServiceResolver *r,
541
AvahiIfIndex interface,
542
AVAHI_GCC_UNUSED AvahiProtocol protocol,
543
AvahiResolverEvent event,
547
const char *host_name,
548
const AvahiAddress *address,
550
AVAHI_GCC_UNUSED AvahiStringList *txt,
551
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
552
AVAHI_GCC_UNUSED void* userdata) {
609
static void resolve_callback(AvahiSServiceResolver *r,
610
AvahiIfIndex interface,
611
AVAHI_GCC_UNUSED AvahiProtocol protocol,
612
AvahiResolverEvent event,
616
const char *host_name,
617
const AvahiAddress *address,
619
AVAHI_GCC_UNUSED AvahiStringList *txt,
620
AVAHI_GCC_UNUSED AvahiLookupResultFlags
623
mandos_context *mc = userdata;
554
624
assert(r); /* Spurious warning */
556
626
/* Called whenever a service has been resolved successfully or
581
651
avahi_s_service_resolver_free(r);
584
static void browse_callback(
585
AvahiSServiceBrowser *b,
586
AvahiIfIndex interface,
587
AvahiProtocol protocol,
588
AvahiBrowserEvent event,
592
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
595
AvahiServer *s = userdata;
596
assert(b); /* Spurious warning */
598
/* Called whenever a new services becomes available on the LAN or
599
is removed from the LAN */
603
case AVAHI_BROWSER_FAILURE:
605
fprintf(stderr, "(Browser) %s\n",
606
avahi_strerror(avahi_server_errno(server)));
607
avahi_simple_poll_quit(simple_poll);
610
case AVAHI_BROWSER_NEW:
611
/* We ignore the returned resolver object. In the callback
612
function we free it. If the server is terminated before
613
the callback function is called the server will free
614
the resolver for us. */
616
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
618
AVAHI_PROTO_INET6, 0,
619
resolve_callback, s)))
620
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
621
avahi_strerror(avahi_server_errno(s)));
624
case AVAHI_BROWSER_REMOVE:
627
case AVAHI_BROWSER_ALL_FOR_NOW:
628
case AVAHI_BROWSER_CACHE_EXHAUSTED:
654
static void browse_callback( AvahiSServiceBrowser *b,
655
AvahiIfIndex interface,
656
AvahiProtocol protocol,
657
AvahiBrowserEvent event,
661
AVAHI_GCC_UNUSED AvahiLookupResultFlags
664
mandos_context *mc = userdata;
665
assert(b); /* Spurious warning */
667
/* Called whenever a new services becomes available on the LAN or
668
is removed from the LAN */
672
case AVAHI_BROWSER_FAILURE:
674
fprintf(stderr, "(Avahi browser) %s\n",
675
avahi_strerror(avahi_server_errno(mc->server)));
676
avahi_simple_poll_quit(mc->simple_poll);
679
case AVAHI_BROWSER_NEW:
680
/* We ignore the returned Avahi resolver object. In the callback
681
function we free it. If the Avahi server is terminated before
682
the callback function is called the Avahi server will free the
685
if (!(avahi_s_service_resolver_new(mc->server, interface,
686
protocol, name, type, domain,
687
AVAHI_PROTO_INET6, 0,
688
resolve_callback, mc)))
689
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
690
name, avahi_strerror(avahi_server_errno(mc->server)));
693
case AVAHI_BROWSER_REMOVE:
696
case AVAHI_BROWSER_ALL_FOR_NOW:
697
case AVAHI_BROWSER_CACHE_EXHAUSTED:
699
fprintf(stderr, "No Mandos server found, still searching...\n");
633
705
/* Combines file name and path and returns the malloced new
643
memcpy(tmp, first, f_len);
715
memcpy(tmp, first, f_len); /* Spurious warning */
645
717
tmp[f_len] = '/';
647
memcpy(tmp + f_len + 1, second, s_len);
719
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
649
721
tmp[f_len + 1 + s_len] = '\0';
654
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
655
AvahiServerConfig config;
726
int main(int argc, char *argv[]){
656
727
AvahiSServiceBrowser *sb = NULL;
659
int returncode = EXIT_SUCCESS;
730
int exitcode = EXIT_SUCCESS;
660
731
const char *interface = "eth0";
661
732
struct ifreq network;
663
736
char *connect_to = NULL;
664
737
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
667
static struct option long_options[] = {
668
{"debug", no_argument, (int *)&debug, 1},
669
{"connect", required_argument, 0, 'C'},
670
{"interface", required_argument, 0, 'i'},
671
{"certdir", required_argument, 0, 'd'},
672
{"certkey", required_argument, 0, 'c'},
673
{"certfile", required_argument, 0, 'k'},
676
int option_index = 0;
677
ret = getopt_long (argc, argv, "i:", long_options,
707
certfile = combinepath(certdir, certfile);
708
if (certfile == NULL){
709
perror("combinepath");
710
returncode = EXIT_FAILURE;
714
certkey = combinepath(certdir, certkey);
715
if (certkey == NULL){
716
perror("combinepath");
717
returncode = EXIT_FAILURE;
738
const char *pubkeyfile = "pubkey.txt";
739
const char *seckeyfile = "seckey.txt";
740
mandos_context mc = { .simple_poll = NULL, .server = NULL,
741
.dh_bits = 1024, .priority = "SECURE256"};
744
struct argp_option options[] = {
745
{ .name = "debug", .key = 128,
746
.doc = "Debug mode", .group = 3 },
747
{ .name = "connect", .key = 'c',
749
.doc = "Connect directly to a sepcified mandos server",
751
{ .name = "interface", .key = 'i',
753
.doc = "Interface that Avahi will conntect through",
755
{ .name = "keydir", .key = 'd',
757
.doc = "Directory where the openpgp keyring is",
759
{ .name = "seckey", .key = 's',
761
.doc = "Secret openpgp key for gnutls authentication",
763
{ .name = "pubkey", .key = 'p',
765
.doc = "Public openpgp key for gnutls authentication",
767
{ .name = "dh-bits", .key = 129,
769
.doc = "dh-bits to use in gnutls communication",
771
{ .name = "priority", .key = 130,
773
.doc = "GNUTLS priority", .group = 1 },
778
error_t parse_opt (int key, char *arg,
779
struct argp_state *state) {
780
/* Get the INPUT argument from `argp_parse', which we know is
781
a pointer to our plugin list pointer. */
803
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
818
return ARGP_ERR_UNKNOWN;
823
struct argp argp = { .options = options, .parser = parse_opt,
825
.doc = "Mandos client -- Get and decrypt"
826
" passwords from mandos server" };
827
argp_parse (&argp, argc, argv, 0, 0, NULL);
830
pubkeyfile = combinepath(keydir, pubkeyfile);
831
if (pubkeyfile == NULL){
832
perror("combinepath");
833
exitcode = EXIT_FAILURE;
837
seckeyfile = combinepath(keydir, seckeyfile);
838
if (seckeyfile == NULL){
839
perror("combinepath");
843
ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
845
fprintf(stderr, "init_gnutls_global\n");
721
862
if_index = (AvahiIfIndex) if_nametoindex(interface);
730
871
char *address = strrchr(connect_to, ':');
731
872
if(address == NULL){
732
873
fprintf(stderr, "No colon in address\n");
874
exitcode = EXIT_FAILURE;
736
878
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
738
880
perror("Bad port number");
881
exitcode = EXIT_FAILURE;
742
885
address = connect_to;
743
ret = start_mandos_communication(address, port, if_index);
886
ret = start_mandos_communication(address, port, if_index, &mc);
888
exitcode = EXIT_FAILURE;
890
exitcode = EXIT_SUCCESS;
751
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
754
returncode = EXIT_FAILURE;
757
strcpy(network.ifr_name, interface);
758
ret = ioctl(sd, SIOCGIFFLAGS, &network);
761
perror("ioctl SIOCGIFFLAGS");
762
returncode = EXIT_FAILURE;
765
if((network.ifr_flags & IFF_UP) == 0){
766
network.ifr_flags |= IFF_UP;
767
ret = ioctl(sd, SIOCSIFFLAGS, &network);
895
/* If the interface is down, bring it up */
897
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
900
exitcode = EXIT_FAILURE;
903
strcpy(network.ifr_name, interface); /* Spurious warning */
904
ret = ioctl(sd, SIOCGIFFLAGS, &network);
769
perror("ioctl SIOCSIFFLAGS");
770
returncode = EXIT_FAILURE;
906
perror("ioctl SIOCGIFFLAGS");
907
exitcode = EXIT_FAILURE;
910
if((network.ifr_flags & IFF_UP) == 0){
911
network.ifr_flags |= IFF_UP;
912
ret = ioctl(sd, SIOCSIFFLAGS, &network);
914
perror("ioctl SIOCSIFFLAGS");
915
exitcode = EXIT_FAILURE;
777
923
avahi_set_log_function(empty_log);
780
/* Initialize the psuedo-RNG */
926
/* Initialize the pseudo-RNG for Avahi */
781
927
srand((unsigned int) time(NULL));
783
/* Allocate main loop object */
784
if (!(simple_poll = avahi_simple_poll_new())) {
785
fprintf(stderr, "Failed to create simple poll object.\n");
786
returncode = EXIT_FAILURE;
790
/* Do not publish any local records */
791
avahi_server_config_init(&config);
792
config.publish_hinfo = 0;
793
config.publish_addresses = 0;
794
config.publish_workstation = 0;
795
config.publish_domain = 0;
797
/* Allocate a new server */
798
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
799
&config, NULL, NULL, &error);
801
/* Free the configuration data */
802
avahi_server_config_free(&config);
804
/* Check if creating the server object succeeded */
806
fprintf(stderr, "Failed to create server: %s\n",
929
/* Allocate main Avahi loop object */
930
mc.simple_poll = avahi_simple_poll_new();
931
if (mc.simple_poll == NULL) {
932
fprintf(stderr, "Avahi: Failed to create simple poll"
934
exitcode = EXIT_FAILURE;
939
AvahiServerConfig config;
940
/* Do not publish any local Zeroconf records */
941
avahi_server_config_init(&config);
942
config.publish_hinfo = 0;
943
config.publish_addresses = 0;
944
config.publish_workstation = 0;
945
config.publish_domain = 0;
947
/* Allocate a new server */
948
mc.server = avahi_server_new(avahi_simple_poll_get
949
(mc.simple_poll), &config, NULL,
952
/* Free the Avahi configuration data */
953
avahi_server_config_free(&config);
956
/* Check if creating the Avahi server object succeeded */
957
if (mc.server == NULL) {
958
fprintf(stderr, "Failed to create Avahi server: %s\n",
807
959
avahi_strerror(error));
808
returncode = EXIT_FAILURE;
960
exitcode = EXIT_FAILURE;
812
/* Create the service browser */
813
sb = avahi_s_service_browser_new(server, if_index,
964
/* Create the Avahi service browser */
965
sb = avahi_s_service_browser_new(mc.server, if_index,
814
966
AVAHI_PROTO_INET6,
815
967
"_mandos._tcp", NULL, 0,
816
browse_callback, server);
968
browse_callback, &mc);
818
970
fprintf(stderr, "Failed to create service browser: %s\n",
819
avahi_strerror(avahi_server_errno(server)));
820
returncode = EXIT_FAILURE;
971
avahi_strerror(avahi_server_errno(mc.server)));
972
exitcode = EXIT_FAILURE;
824
976
/* Run the main loop */
827
fprintf(stderr, "Starting avahi loop search\n");
979
fprintf(stderr, "Starting Avahi loop search\n");
830
avahi_simple_poll_loop(simple_poll);
982
avahi_simple_poll_loop(mc.simple_poll);
835
987
fprintf(stderr, "%s exiting\n", argv[0]);
838
990
/* Cleanup things */
840
992
avahi_s_service_browser_free(sb);
843
avahi_server_free(server);
994
if (mc.server != NULL)
995
avahi_server_free(mc.server);
846
avahi_simple_poll_free(simple_poll);
997
if (mc.simple_poll != NULL)
998
avahi_simple_poll_free(mc.simple_poll);