/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 16:05:52 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080803160552-mvqy5klry3wn57x1
* plugins.d/mandosclient.c (initgnutls): Moved "err" variable into its
                                         own code block.
  (start_mandos_communication): Moved call to "initgnutls" to
                                beginning.  Renamed label "exit" to
                                "mandos_end".  Bug fix: set return
                                code if failure to realloc buffer.
                                Close TLS session as early as
                                possible.
  (resolve_callback): Also print interface number when debugging.
  (main): Moved "debug_int" and "config" into their own respective
          code blocks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
49
49
#include <avahi-common/malloc.h>
50
50
#include <avahi-common/error.h>
51
51
 
52
 
//mandos client part
 
52
/* Mandos client part */
53
53
#include <sys/types.h>          /* socket(), inet_pton() */
54
54
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
55
55
                                   struct in6_addr, inet_pton() */
62
62
#include <string.h>             /* memset */
63
63
#include <arpa/inet.h>          /* inet_pton() */
64
64
#include <iso646.h>             /* not */
 
65
#include <net/if.h>             /* IF_NAMESIZE */
65
66
 
66
 
// gpgme
 
67
/* GPGME */
67
68
#include <errno.h>              /* perror() */
68
69
#include <gpgme.h>
69
70
 
70
 
// getopt_long
 
71
/* getopt_long */
71
72
#include <getopt.h>
72
73
 
73
74
#define BUFFER_SIZE 256
99
100
  gpgme_ctx_t ctx;
100
101
  gpgme_error_t rc;
101
102
  ssize_t ret;
102
 
  ssize_t plaintext_capacity = 0;
 
103
  size_t plaintext_capacity = 0;
103
104
  ssize_t plaintext_length = 0;
104
105
  gpgme_engine_info_t engine_info;
105
106
  
215
216
  
216
217
  *plaintext = NULL;
217
218
  while(true){
218
 
    if (plaintext_length + BUFFER_SIZE > plaintext_capacity){
219
 
      *plaintext = realloc(*plaintext,
220
 
                            (unsigned int)plaintext_capacity
 
219
    if (plaintext_length + BUFFER_SIZE
 
220
        > (ssize_t) plaintext_capacity){
 
221
      *plaintext = realloc(*plaintext, plaintext_capacity
221
222
                            + BUFFER_SIZE);
222
223
      if (*plaintext == NULL){
223
224
        perror("realloc");
244
245
 
245
246
  if(debug){
246
247
    fprintf(stderr, "Decrypted password is: ");
247
 
    for(size_t i = 0; i < plaintext_length; i++){
 
248
    for(ssize_t i = 0; i < plaintext_length; i++){
248
249
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
249
250
    }
250
251
    fprintf(stderr, "\n");
267
268
  return ret;
268
269
}
269
270
 
 
271
/* GnuTLS log function callback */
270
272
static void debuggnutls(__attribute__((unused)) int level,
271
273
                        const char* string){
272
 
  fprintf(stderr, "%s", string);
 
274
  fprintf(stderr, "GnuTLS: %s", string);
273
275
}
274
276
 
275
277
static int initgnutls(mandos_context *mc, gnutls_session_t *session,
276
278
                      gnutls_dh_params_t *dh_params){
277
 
  const char *err;
278
279
  int ret;
279
280
  
280
281
  if(debug){
283
284
 
284
285
  if ((ret = gnutls_global_init ())
285
286
      != GNUTLS_E_SUCCESS) {
286
 
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
287
    fprintf (stderr, "GnuTLS global_init: %s\n",
 
288
             safer_gnutls_strerror(ret));
287
289
    return -1;
288
290
  }
289
291
  
290
292
  if (debug){
 
293
    /* "Use a log level over 10 to enable all debugging options."
 
294
     * - GnuTLS manual
 
295
     */
291
296
    gnutls_global_set_log_level(11);
292
297
    gnutls_global_set_log_function(debuggnutls);
293
298
  }
294
299
  
295
 
  /* openpgp credentials */
 
300
  /* OpenPGP credentials */
296
301
  if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
297
302
      != GNUTLS_E_SUCCESS) {
298
 
    fprintf (stderr, "memory error: %s\n",
 
303
    fprintf (stderr, "GnuTLS memory error: %s\n",
299
304
             safer_gnutls_strerror(ret));
300
305
    return -1;
301
306
  }
309
314
  ret = gnutls_certificate_set_openpgp_key_file
310
315
    (mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
311
316
  if (ret != GNUTLS_E_SUCCESS) {
312
 
    fprintf
313
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
314
 
       " '%s')\n",
315
 
       ret, pubkeyfile, seckeyfile);
316
 
    fprintf(stdout, "The Error is: %s\n",
 
317
    fprintf(stderr,
 
318
            "Error[%d] while reading the OpenPGP key pair ('%s',"
 
319
            " '%s')\n", ret, pubkeyfile, seckeyfile);
 
320
    fprintf(stdout, "The GnuTLS error is: %s\n",
317
321
            safer_gnutls_strerror(ret));
318
322
    return -1;
319
323
  }
320
324
  
321
 
  //GnuTLS server initialization
322
 
  if ((ret = gnutls_dh_params_init(dh_params))
323
 
      != GNUTLS_E_SUCCESS) {
324
 
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
325
 
             safer_gnutls_strerror(ret));
 
325
  /* GnuTLS server initialization */
 
326
  ret = gnutls_dh_params_init(dh_params);
 
327
  if (ret != GNUTLS_E_SUCCESS) {
 
328
    fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
 
329
             " %s\n", safer_gnutls_strerror(ret));
326
330
    return -1;
327
331
  }
328
 
  
329
 
  if ((ret = gnutls_dh_params_generate2(*dh_params, mc->dh_bits))
330
 
      != GNUTLS_E_SUCCESS) {
331
 
    fprintf (stderr, "Error in prime generation: %s\n",
 
332
  ret = gnutls_dh_params_generate2(*dh_params, mc->dh_bits);
 
333
  if (ret != GNUTLS_E_SUCCESS) {
 
334
    fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
332
335
             safer_gnutls_strerror(ret));
333
336
    return -1;
334
337
  }
335
338
  
336
339
  gnutls_certificate_set_dh_params(mc->cred, *dh_params);
337
340
  
338
 
  // GnuTLS session creation
339
 
  if ((ret = gnutls_init(session, GNUTLS_SERVER))
340
 
      != GNUTLS_E_SUCCESS){
 
341
  /* GnuTLS session creation */
 
342
  ret = gnutls_init(session, GNUTLS_SERVER);
 
343
  if (ret != GNUTLS_E_SUCCESS){
341
344
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
342
345
            safer_gnutls_strerror(ret));
343
346
  }
344
347
  
345
 
  if ((ret = gnutls_priority_set_direct(*session, mc->priority, &err))
346
 
      != GNUTLS_E_SUCCESS) {
347
 
    fprintf(stderr, "Syntax error at: %s\n", err);
348
 
    fprintf(stderr, "GnuTLS error: %s\n",
349
 
            safer_gnutls_strerror(ret));
350
 
    return -1;
 
348
  {
 
349
    const char *err;
 
350
    ret = gnutls_priority_set_direct(*session, mc->priority, &err);
 
351
    if (ret != GNUTLS_E_SUCCESS) {
 
352
      fprintf(stderr, "Syntax error at: %s\n", err);
 
353
      fprintf(stderr, "GnuTLS error: %s\n",
 
354
              safer_gnutls_strerror(ret));
 
355
      return -1;
 
356
    }
351
357
  }
352
358
  
353
 
  if ((ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
354
 
                                    mc->cred))
355
 
      != GNUTLS_E_SUCCESS) {
356
 
    fprintf(stderr, "Error setting a credentials set: %s\n",
 
359
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
360
                               mc->cred);
 
361
  if (ret != GNUTLS_E_SUCCESS) {
 
362
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
357
363
            safer_gnutls_strerror(ret));
358
364
    return -1;
359
365
  }
367
373
  return 0;
368
374
}
369
375
 
 
376
/* Avahi log function callback */
370
377
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
371
378
                      __attribute__((unused)) const char *txt){}
372
379
 
 
380
/* Called when a Mandos server is found */
373
381
static int start_mandos_communication(const char *ip, uint16_t port,
374
382
                                      AvahiIfIndex if_index,
375
383
                                      mandos_context *mc){
386
394
  gnutls_session_t session;
387
395
  gnutls_dh_params_t dh_params;
388
396
  
 
397
  ret = initgnutls (mc, &session, &dh_params);
 
398
  if (ret != 0){
 
399
    return -1;
 
400
  }
 
401
  
389
402
  if(debug){
390
403
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
391
404
            ip, port);
407
420
  
408
421
  memset(&to,0,sizeof(to));     /* Spurious warning */
409
422
  to.sin6_family = AF_INET6;
 
423
  /* It would be nice to have a way to detect if we were passed an
 
424
     IPv4 address here.   Now we assume an IPv6 address. */
410
425
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
411
426
  if (ret < 0 ){
412
427
    perror("inet_pton");
439
454
    return -1;
440
455
  }
441
456
  
442
 
  ret = initgnutls (mc, &session, &dh_params);
443
 
  if (ret != 0){
444
 
    retval = -1;
445
 
    return -1;
 
457
  if(debug){
 
458
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
446
459
  }
447
460
  
448
461
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
449
462
  
450
 
  if(debug){
451
 
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
452
 
  }
453
 
  
454
463
  ret = gnutls_handshake (session);
455
464
  
456
465
  if (ret != GNUTLS_E_SUCCESS){
457
466
    if(debug){
458
 
      fprintf(stderr, "\n*** Handshake failed ***\n");
 
467
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
459
468
      gnutls_perror (ret);
460
469
    }
461
470
    retval = -1;
462
 
    goto exit;
 
471
    goto mandos_end;
463
472
  }
464
473
  
465
 
  //Retrieve OpenPGP packet that contains the wanted password
 
474
  /* Read OpenPGP packet that contains the wanted password */
466
475
  
467
476
  if(debug){
468
477
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
474
483
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
475
484
      if (buffer == NULL){
476
485
        perror("realloc");
477
 
        goto exit;
 
486
        retval = -1;
 
487
        goto mandos_end;
478
488
      }
479
489
      buffer_capacity += BUFFER_SIZE;
480
490
    }
492
502
      case GNUTLS_E_REHANDSHAKE:
493
503
        ret = gnutls_handshake (session);
494
504
        if (ret < 0){
495
 
          fprintf(stderr, "\n*** Handshake failed ***\n");
 
505
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
496
506
          gnutls_perror (ret);
497
507
          retval = -1;
498
 
          goto exit;
 
508
          goto mandos_end;
499
509
        }
500
510
        break;
501
511
      default:
502
512
        fprintf(stderr, "Unknown error while reading data from"
503
 
                " encrypted session with mandos server\n");
 
513
                " encrypted session with Mandos server\n");
504
514
        retval = -1;
505
515
        gnutls_bye (session, GNUTLS_SHUT_RDWR);
506
 
        goto exit;
 
516
        goto mandos_end;
507
517
      }
508
518
    } else {
509
519
      buffer_length += (size_t) ret;
510
520
    }
511
521
  }
512
522
  
 
523
  if(debug){
 
524
    fprintf(stderr, "Closing TLS session\n");
 
525
  }
 
526
  
 
527
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
528
  
513
529
  if (buffer_length > 0){
514
530
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
515
531
                                               buffer_length,
535
551
      retval = -1;
536
552
    }
537
553
  }
538
 
 
539
 
  //shutdown procedure
540
 
 
541
 
  if(debug){
542
 
    fprintf(stderr, "Closing TLS session\n");
543
 
  }
544
 
 
 
554
  
 
555
  /* Shutdown procedure */
 
556
  
 
557
 mandos_end:
545
558
  free(buffer);
546
 
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
547
 
 exit:
548
559
  close(tcp_sd);
549
560
  gnutls_deinit (session);
550
561
  gnutls_certificate_free_credentials (mc->cred);
575
586
  switch (event) {
576
587
  default:
577
588
  case AVAHI_RESOLVER_FAILURE:
578
 
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
579
 
            " type '%s' in domain '%s': %s\n", name, type, domain,
 
589
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
 
590
            " of type '%s' in domain '%s': %s\n", name, type, domain,
580
591
            avahi_strerror(avahi_server_errno(mc->server)));
581
592
    break;
582
593
    
585
596
      char ip[AVAHI_ADDRESS_STR_MAX];
586
597
      avahi_address_snprint(ip, sizeof(ip), address);
587
598
      if(debug){
588
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
589
 
                " port %d\n", name, host_name, ip, port);
 
599
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %d) on"
 
600
                " port %d\n", name, host_name, ip, interface, port);
590
601
      }
591
602
      int ret = start_mandos_communication(ip, port, interface, mc);
592
603
      if (ret == 0){
617
628
  default:
618
629
  case AVAHI_BROWSER_FAILURE:
619
630
    
620
 
    fprintf(stderr, "(Browser) %s\n",
 
631
    fprintf(stderr, "(Avahi browser) %s\n",
621
632
            avahi_strerror(avahi_server_errno(mc->server)));
622
633
    avahi_simple_poll_quit(mc->simple_poll);
623
634
    return;
624
635
    
625
636
  case AVAHI_BROWSER_NEW:
626
 
    /* We ignore the returned resolver object. In the callback
627
 
       function we free it. If the server is terminated before
628
 
       the callback function is called the server will free
629
 
       the resolver for us. */
 
637
    /* We ignore the returned Avahi resolver object. In the callback
 
638
       function we free it. If the Avahi server is terminated before
 
639
       the callback function is called the Avahi server will free the
 
640
       resolver for us. */
630
641
    
631
642
    if (!(avahi_s_service_resolver_new(mc->server, interface,
632
643
                                       protocol, name, type, domain,
633
644
                                       AVAHI_PROTO_INET6, 0,
634
645
                                       resolve_callback, mc)))
635
 
      fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
636
 
              avahi_strerror(avahi_server_errno(mc->server)));
 
646
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
 
647
              name, avahi_strerror(avahi_server_errno(mc->server)));
637
648
    break;
638
649
    
639
650
  case AVAHI_BROWSER_REMOVE:
641
652
    
642
653
  case AVAHI_BROWSER_ALL_FOR_NOW:
643
654
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
655
    if(debug){
 
656
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
657
    }
644
658
    break;
645
659
  }
646
660
}
666
680
}
667
681
 
668
682
 
669
 
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
670
 
    AvahiServerConfig config;
 
683
int main(int argc, char *argv[]){
671
684
    AvahiSServiceBrowser *sb = NULL;
672
685
    int error;
673
686
    int ret;
674
 
    int debug_int;
675
 
    int returncode = EXIT_SUCCESS;
 
687
    int exitcode = EXIT_SUCCESS;
676
688
    const char *interface = "eth0";
677
689
    struct ifreq network;
678
690
    int sd;
681
693
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
682
694
                          .dh_bits = 1024, .priority = "SECURE256"};
683
695
    
684
 
    debug_int = debug ? 1 : 0;
685
 
    while (true){
686
 
      struct option long_options[] = {
687
 
        {"debug", no_argument, &debug_int, 1},
688
 
        {"connect", required_argument, NULL, 'c'},
689
 
        {"interface", required_argument, NULL, 'i'},
690
 
        {"keydir", required_argument, NULL, 'd'},
691
 
        {"seckey", required_argument, NULL, 's'},
692
 
        {"pubkey", required_argument, NULL, 'p'},
693
 
        {"dh-bits", required_argument, NULL, 'D'},
694
 
        {"priority", required_argument, NULL, 'P'},
695
 
        {0, 0, 0, 0} };
696
 
      
697
 
      int option_index = 0;
698
 
      ret = getopt_long (argc, argv, "i:", long_options,
699
 
                         &option_index);
700
 
      
701
 
      if (ret == -1){
702
 
        break;
703
 
      }
704
 
      
705
 
      switch(ret){
706
 
      case 0:
707
 
        break;
708
 
      case 'i':
709
 
        interface = optarg;
710
 
        break;
711
 
      case 'c':
712
 
        connect_to = optarg;
713
 
        break;
714
 
      case 'd':
715
 
        keydir = optarg;
716
 
        break;
717
 
      case 'p':
718
 
        pubkeyfile = optarg;
719
 
        break;
720
 
      case 's':
721
 
        seckeyfile = optarg;
722
 
        break;
723
 
      case 'D':
724
 
        errno = 0;
725
 
        mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
726
 
        if (errno){
727
 
          perror("strtol");
 
696
    {
 
697
      /* Temporary int to get the address of for getopt_long */
 
698
      int debug_int = debug ? 1 : 0;
 
699
      while (true){
 
700
        struct option long_options[] = {
 
701
          {"debug", no_argument, &debug_int, 1},
 
702
          {"connect", required_argument, NULL, 'c'},
 
703
          {"interface", required_argument, NULL, 'i'},
 
704
          {"keydir", required_argument, NULL, 'd'},
 
705
          {"seckey", required_argument, NULL, 's'},
 
706
          {"pubkey", required_argument, NULL, 'p'},
 
707
          {"dh-bits", required_argument, NULL, 'D'},
 
708
          {"priority", required_argument, NULL, 'P'},
 
709
          {0, 0, 0, 0} };
 
710
      
 
711
        int option_index = 0;
 
712
        ret = getopt_long (argc, argv, "i:", long_options,
 
713
                           &option_index);
 
714
      
 
715
        if (ret == -1){
 
716
          break;
 
717
        }
 
718
      
 
719
        switch(ret){
 
720
        case 0:
 
721
          break;
 
722
        case 'i':
 
723
          interface = optarg;
 
724
          break;
 
725
        case 'c':
 
726
          connect_to = optarg;
 
727
          break;
 
728
        case 'd':
 
729
          keydir = optarg;
 
730
          break;
 
731
        case 'p':
 
732
          pubkeyfile = optarg;
 
733
          break;
 
734
        case 's':
 
735
          seckeyfile = optarg;
 
736
          break;
 
737
        case 'D':
 
738
          errno = 0;
 
739
          mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
 
740
          if (errno){
 
741
            perror("strtol");
 
742
            exit(EXIT_FAILURE);
 
743
          }
 
744
          break;
 
745
        case 'P':
 
746
          mc.priority = optarg;
 
747
          break;
 
748
        case '?':
 
749
        default:
 
750
          /* getopt_long() has already printed a message about the
 
751
             unrcognized option, so just exit. */
728
752
          exit(EXIT_FAILURE);
729
753
        }
730
 
        break;
731
 
      case 'P':
732
 
        mc.priority = optarg;
733
 
        break;
734
 
      case '?':
735
 
      default:
736
 
        exit(EXIT_FAILURE);
737
754
      }
 
755
      /* Set the global debug flag from the temporary int */
 
756
      debug = debug_int ? true : false;
738
757
    }
739
 
    debug = debug_int ? true : false;
740
758
    
741
759
    pubkeyfile = combinepath(keydir, pubkeyfile);
742
760
    if (pubkeyfile == NULL){
743
761
      perror("combinepath");
744
 
      returncode = EXIT_FAILURE;
745
 
      goto exit;
 
762
      exitcode = EXIT_FAILURE;
 
763
      goto end;
746
764
    }
747
765
    
748
766
    seckeyfile = combinepath(keydir, seckeyfile);
749
767
    if (seckeyfile == NULL){
750
768
      perror("combinepath");
751
 
      goto exit;
 
769
      goto end;
752
770
    }
753
771
    
754
772
    if_index = (AvahiIfIndex) if_nametoindex(interface);
781
799
      }
782
800
    }
783
801
    
784
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
785
 
    if(sd < 0) {
786
 
      perror("socket");
787
 
      returncode = EXIT_FAILURE;
788
 
      goto exit;
789
 
    }
790
 
    strcpy(network.ifr_name, interface); /* Spurious warning */
791
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
792
 
    if(ret == -1){
793
 
      
794
 
      perror("ioctl SIOCGIFFLAGS");
795
 
      returncode = EXIT_FAILURE;
796
 
      goto exit;
797
 
    }
798
 
    if((network.ifr_flags & IFF_UP) == 0){
799
 
      network.ifr_flags |= IFF_UP;
800
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
802
    /* If the interface is down, bring it up */
 
803
    {
 
804
      sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
805
      if(sd < 0) {
 
806
        perror("socket");
 
807
        exitcode = EXIT_FAILURE;
 
808
        goto end;
 
809
      }
 
810
      strcpy(network.ifr_name, interface); /* Spurious warning */
 
811
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
801
812
      if(ret == -1){
802
 
        perror("ioctl SIOCSIFFLAGS");
803
 
        returncode = EXIT_FAILURE;
804
 
        goto exit;
805
 
      }
 
813
        perror("ioctl SIOCGIFFLAGS");
 
814
        exitcode = EXIT_FAILURE;
 
815
        goto end;
 
816
      }
 
817
      if((network.ifr_flags & IFF_UP) == 0){
 
818
        network.ifr_flags |= IFF_UP;
 
819
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
820
        if(ret == -1){
 
821
          perror("ioctl SIOCSIFFLAGS");
 
822
          exitcode = EXIT_FAILURE;
 
823
          goto end;
 
824
        }
 
825
      }
 
826
      close(sd);
806
827
    }
807
 
    close(sd);
808
828
    
809
829
    if (not debug){
810
830
      avahi_set_log_function(empty_log);
811
831
    }
812
832
    
813
 
    /* Initialize the psuedo-RNG */
 
833
    /* Initialize the pseudo-RNG for Avahi */
814
834
    srand((unsigned int) time(NULL));
815
 
 
816
 
    /* Allocate main loop object */
817
 
    if (!(mc.simple_poll = avahi_simple_poll_new())) {
818
 
        fprintf(stderr, "Failed to create simple poll object.\n");
819
 
        returncode = EXIT_FAILURE;
820
 
        goto exit;
821
 
    }
822
 
 
823
 
    /* Do not publish any local records */
824
 
    avahi_server_config_init(&config);
825
 
    config.publish_hinfo = 0;
826
 
    config.publish_addresses = 0;
827
 
    config.publish_workstation = 0;
828
 
    config.publish_domain = 0;
829
 
 
830
 
    /* Allocate a new server */
831
 
    mc.server=avahi_server_new(avahi_simple_poll_get(mc.simple_poll),
832
 
                               &config, NULL, NULL, &error);
833
 
    
834
 
    /* Free the configuration data */
835
 
    avahi_server_config_free(&config);
836
 
    
837
 
    /* Check if creating the server object succeeded */
838
 
    if (!mc.server) {
839
 
        fprintf(stderr, "Failed to create server: %s\n",
 
835
    
 
836
    /* Allocate main Avahi loop object */
 
837
    mc.simple_poll = avahi_simple_poll_new();
 
838
    if (mc.simple_poll == NULL) {
 
839
        fprintf(stderr, "Avahi: Failed to create simple poll"
 
840
                " object.\n");
 
841
        exitcode = EXIT_FAILURE;
 
842
        goto end;
 
843
    }
 
844
 
 
845
    {
 
846
      AvahiServerConfig config;
 
847
      /* Do not publish any local Zeroconf records */
 
848
      avahi_server_config_init(&config);
 
849
      config.publish_hinfo = 0;
 
850
      config.publish_addresses = 0;
 
851
      config.publish_workstation = 0;
 
852
      config.publish_domain = 0;
 
853
 
 
854
      /* Allocate a new server */
 
855
      mc.server = avahi_server_new(avahi_simple_poll_get
 
856
                                   (mc.simple_poll), &config, NULL,
 
857
                                   NULL, &error);
 
858
    
 
859
      /* Free the Avahi configuration data */
 
860
      avahi_server_config_free(&config);
 
861
    }
 
862
    
 
863
    /* Check if creating the Avahi server object succeeded */
 
864
    if (mc.server == NULL) {
 
865
        fprintf(stderr, "Failed to create Avahi server: %s\n",
840
866
                avahi_strerror(error));
841
 
        returncode = EXIT_FAILURE;
842
 
        goto exit;
 
867
        exitcode = EXIT_FAILURE;
 
868
        goto end;
843
869
    }
844
870
    
845
 
    /* Create the service browser */
 
871
    /* Create the Avahi service browser */
846
872
    sb = avahi_s_service_browser_new(mc.server, if_index,
847
873
                                     AVAHI_PROTO_INET6,
848
874
                                     "_mandos._tcp", NULL, 0,
849
875
                                     browse_callback, &mc);
850
 
    if (!sb) {
 
876
    if (sb == NULL) {
851
877
        fprintf(stderr, "Failed to create service browser: %s\n",
852
878
                avahi_strerror(avahi_server_errno(mc.server)));
853
 
        returncode = EXIT_FAILURE;
854
 
        goto exit;
 
879
        exitcode = EXIT_FAILURE;
 
880
        goto end;
855
881
    }
856
882
    
857
883
    /* Run the main loop */
858
884
 
859
885
    if (debug){
860
 
      fprintf(stderr, "Starting avahi loop search\n");
 
886
      fprintf(stderr, "Starting Avahi loop search\n");
861
887
    }
862
888
    
863
889
    avahi_simple_poll_loop(mc.simple_poll);
864
890
    
865
 
 exit:
 
891
 end:
866
892
 
867
893
    if (debug){
868
894
      fprintf(stderr, "%s exiting\n", argv[0]);
869
895
    }
870
896
    
871
897
    /* Cleanup things */
872
 
    if (sb)
 
898
    if (sb != NULL)
873
899
        avahi_s_service_browser_free(sb);
874
900
    
875
 
    if (mc.server)
 
901
    if (mc.server != NULL)
876
902
        avahi_server_free(mc.server);
877
903
 
878
 
    if (mc.simple_poll)
 
904
    if (mc.simple_poll != NULL)
879
905
        avahi_simple_poll_free(mc.simple_poll);
880
906
    free(pubkeyfile);
881
907
    free(seckeyfile);
882
908
    
883
 
    return returncode;
 
909
    return exitcode;
884
910
}