/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 03:33:56 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080803033356-6aemgj0g0hoz91ow
* plugins.d/mandosclient.c (pgp_packet_decrypt): Renamed variables.
                                                 On debug, show
                                                 decrypted plaintext
                                                 in hexadecimal.  Free
                                                 the GPGME data
                                                 buffers even on
                                                 errors.

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 */
66
65
 
67
 
/* GPGME */
 
66
// gpgme
68
67
#include <errno.h>              /* perror() */
69
68
#include <gpgme.h>
70
69
 
71
 
/* getopt_long */
 
70
// getopt_long
72
71
#include <getopt.h>
73
72
 
74
73
#define BUFFER_SIZE 256
100
99
  gpgme_ctx_t ctx;
101
100
  gpgme_error_t rc;
102
101
  ssize_t ret;
103
 
  size_t plaintext_capacity = 0;
 
102
  ssize_t plaintext_capacity = 0;
104
103
  ssize_t plaintext_length = 0;
105
104
  gpgme_engine_info_t engine_info;
106
105
  
216
215
  
217
216
  *plaintext = NULL;
218
217
  while(true){
219
 
    if (plaintext_length + BUFFER_SIZE
220
 
        > (ssize_t) plaintext_capacity){
221
 
      *plaintext = realloc(*plaintext, plaintext_capacity
 
218
    if (plaintext_length + BUFFER_SIZE > plaintext_capacity){
 
219
      *plaintext = realloc(*plaintext,
 
220
                            (unsigned int)plaintext_capacity
222
221
                            + BUFFER_SIZE);
223
222
      if (*plaintext == NULL){
224
223
        perror("realloc");
245
244
 
246
245
  if(debug){
247
246
    fprintf(stderr, "Decrypted password is: ");
248
 
    for(ssize_t i = 0; i < plaintext_length; i++){
 
247
    for(size_t i = 0; i < plaintext_length; i++){
249
248
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
250
249
    }
251
250
    fprintf(stderr, "\n");
268
267
  return ret;
269
268
}
270
269
 
271
 
/* GnuTLS log function callback */
272
270
static void debuggnutls(__attribute__((unused)) int level,
273
271
                        const char* string){
274
 
  fprintf(stderr, "GnuTLS: %s", string);
 
272
  fprintf(stderr, "%s", string);
275
273
}
276
274
 
277
275
static int initgnutls(mandos_context *mc, gnutls_session_t *session,
278
276
                      gnutls_dh_params_t *dh_params){
 
277
  const char *err;
279
278
  int ret;
280
279
  
281
280
  if(debug){
284
283
 
285
284
  if ((ret = gnutls_global_init ())
286
285
      != GNUTLS_E_SUCCESS) {
287
 
    fprintf (stderr, "GnuTLS global_init: %s\n",
288
 
             safer_gnutls_strerror(ret));
 
286
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
289
287
    return -1;
290
288
  }
291
289
  
292
290
  if (debug){
293
 
    /* "Use a log level over 10 to enable all debugging options."
294
 
     * - GnuTLS manual
295
 
     */
296
291
    gnutls_global_set_log_level(11);
297
292
    gnutls_global_set_log_function(debuggnutls);
298
293
  }
299
294
  
300
 
  /* OpenPGP credentials */
 
295
  /* openpgp credentials */
301
296
  if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
302
297
      != GNUTLS_E_SUCCESS) {
303
 
    fprintf (stderr, "GnuTLS memory error: %s\n",
 
298
    fprintf (stderr, "memory error: %s\n",
304
299
             safer_gnutls_strerror(ret));
305
300
    return -1;
306
301
  }
314
309
  ret = gnutls_certificate_set_openpgp_key_file
315
310
    (mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
316
311
  if (ret != GNUTLS_E_SUCCESS) {
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",
 
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",
321
317
            safer_gnutls_strerror(ret));
322
318
    return -1;
323
319
  }
324
320
  
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));
 
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));
330
326
    return -1;
331
327
  }
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",
 
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",
335
332
             safer_gnutls_strerror(ret));
336
333
    return -1;
337
334
  }
338
335
  
339
336
  gnutls_certificate_set_dh_params(mc->cred, *dh_params);
340
337
  
341
 
  /* GnuTLS session creation */
342
 
  ret = gnutls_init(session, GNUTLS_SERVER);
343
 
  if (ret != GNUTLS_E_SUCCESS){
 
338
  // GnuTLS session creation
 
339
  if ((ret = gnutls_init(session, GNUTLS_SERVER))
 
340
      != GNUTLS_E_SUCCESS){
344
341
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
345
342
            safer_gnutls_strerror(ret));
346
343
  }
347
344
  
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
 
    }
 
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;
357
351
  }
358
352
  
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",
 
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",
363
357
            safer_gnutls_strerror(ret));
364
358
    return -1;
365
359
  }
373
367
  return 0;
374
368
}
375
369
 
376
 
/* Avahi log function callback */
377
370
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
378
371
                      __attribute__((unused)) const char *txt){}
379
372
 
380
 
/* Called when a Mandos server is found */
381
373
static int start_mandos_communication(const char *ip, uint16_t port,
382
374
                                      AvahiIfIndex if_index,
383
375
                                      mandos_context *mc){
394
386
  gnutls_session_t session;
395
387
  gnutls_dh_params_t dh_params;
396
388
  
397
 
  ret = initgnutls (mc, &session, &dh_params);
398
 
  if (ret != 0){
399
 
    return -1;
400
 
  }
401
 
  
402
389
  if(debug){
403
390
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
404
391
            ip, port);
420
407
  
421
408
  memset(&to,0,sizeof(to));     /* Spurious warning */
422
409
  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. */
425
410
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
426
411
  if (ret < 0 ){
427
412
    perror("inet_pton");
454
439
    return -1;
455
440
  }
456
441
  
 
442
  ret = initgnutls (mc, &session, &dh_params);
 
443
  if (ret != 0){
 
444
    retval = -1;
 
445
    return -1;
 
446
  }
 
447
  
 
448
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
 
449
  
457
450
  if(debug){
458
451
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
459
452
  }
460
453
  
461
 
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
462
 
  
463
454
  ret = gnutls_handshake (session);
464
455
  
465
456
  if (ret != GNUTLS_E_SUCCESS){
466
457
    if(debug){
467
 
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
458
      fprintf(stderr, "\n*** Handshake failed ***\n");
468
459
      gnutls_perror (ret);
469
460
    }
470
461
    retval = -1;
471
 
    goto mandos_end;
 
462
    goto exit;
472
463
  }
473
464
  
474
 
  /* Read OpenPGP packet that contains the wanted password */
 
465
  //Retrieve OpenPGP packet that contains the wanted password
475
466
  
476
467
  if(debug){
477
468
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
483
474
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
484
475
      if (buffer == NULL){
485
476
        perror("realloc");
486
 
        retval = -1;
487
 
        goto mandos_end;
 
477
        goto exit;
488
478
      }
489
479
      buffer_capacity += BUFFER_SIZE;
490
480
    }
502
492
      case GNUTLS_E_REHANDSHAKE:
503
493
        ret = gnutls_handshake (session);
504
494
        if (ret < 0){
505
 
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
495
          fprintf(stderr, "\n*** Handshake failed ***\n");
506
496
          gnutls_perror (ret);
507
497
          retval = -1;
508
 
          goto mandos_end;
 
498
          goto exit;
509
499
        }
510
500
        break;
511
501
      default:
512
502
        fprintf(stderr, "Unknown error while reading data from"
513
 
                " encrypted session with Mandos server\n");
 
503
                " encrypted session with mandos server\n");
514
504
        retval = -1;
515
505
        gnutls_bye (session, GNUTLS_SHUT_RDWR);
516
 
        goto mandos_end;
 
506
        goto exit;
517
507
      }
518
508
    } else {
519
509
      buffer_length += (size_t) ret;
520
510
    }
521
511
  }
522
512
  
523
 
  if(debug){
524
 
    fprintf(stderr, "Closing TLS session\n");
525
 
  }
526
 
  
527
 
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
528
 
  
529
513
  if (buffer_length > 0){
530
514
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
531
515
                                               buffer_length,
551
535
      retval = -1;
552
536
    }
553
537
  }
554
 
  
555
 
  /* Shutdown procedure */
556
 
  
557
 
 mandos_end:
 
538
 
 
539
  //shutdown procedure
 
540
 
 
541
  if(debug){
 
542
    fprintf(stderr, "Closing TLS session\n");
 
543
  }
 
544
 
558
545
  free(buffer);
 
546
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
547
 exit:
559
548
  close(tcp_sd);
560
549
  gnutls_deinit (session);
561
550
  gnutls_certificate_free_credentials (mc->cred);
586
575
  switch (event) {
587
576
  default:
588
577
  case AVAHI_RESOLVER_FAILURE:
589
 
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
590
 
            " of type '%s' in domain '%s': %s\n", name, type, domain,
 
578
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
 
579
            " type '%s' in domain '%s': %s\n", name, type, domain,
591
580
            avahi_strerror(avahi_server_errno(mc->server)));
592
581
    break;
593
582
    
596
585
      char ip[AVAHI_ADDRESS_STR_MAX];
597
586
      avahi_address_snprint(ip, sizeof(ip), address);
598
587
      if(debug){
599
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %d) on"
600
 
                " port %d\n", name, host_name, ip, interface, port);
 
588
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
 
589
                " port %d\n", name, host_name, ip, port);
601
590
      }
602
591
      int ret = start_mandos_communication(ip, port, interface, mc);
603
592
      if (ret == 0){
628
617
  default:
629
618
  case AVAHI_BROWSER_FAILURE:
630
619
    
631
 
    fprintf(stderr, "(Avahi browser) %s\n",
 
620
    fprintf(stderr, "(Browser) %s\n",
632
621
            avahi_strerror(avahi_server_errno(mc->server)));
633
622
    avahi_simple_poll_quit(mc->simple_poll);
634
623
    return;
635
624
    
636
625
  case AVAHI_BROWSER_NEW:
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. */
 
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. */
641
630
    
642
631
    if (!(avahi_s_service_resolver_new(mc->server, interface,
643
632
                                       protocol, name, type, domain,
644
633
                                       AVAHI_PROTO_INET6, 0,
645
634
                                       resolve_callback, mc)))
646
 
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
647
 
              name, avahi_strerror(avahi_server_errno(mc->server)));
 
635
      fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
 
636
              avahi_strerror(avahi_server_errno(mc->server)));
648
637
    break;
649
638
    
650
639
  case AVAHI_BROWSER_REMOVE:
652
641
    
653
642
  case AVAHI_BROWSER_ALL_FOR_NOW:
654
643
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
655
 
    if(debug){
656
 
      fprintf(stderr, "No Mandos server found, still searching...\n");
657
 
    }
658
644
    break;
659
645
  }
660
646
}
680
666
}
681
667
 
682
668
 
683
 
int main(int argc, char *argv[]){
 
669
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
670
    AvahiServerConfig config;
684
671
    AvahiSServiceBrowser *sb = NULL;
685
672
    int error;
686
673
    int ret;
687
 
    int exitcode = EXIT_SUCCESS;
 
674
    int debug_int;
 
675
    int returncode = EXIT_SUCCESS;
688
676
    const char *interface = "eth0";
689
677
    struct ifreq network;
690
678
    int sd;
693
681
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
694
682
                          .dh_bits = 1024, .priority = "SECURE256"};
695
683
    
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. */
 
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");
752
728
          exit(EXIT_FAILURE);
753
729
        }
 
730
        break;
 
731
      case 'P':
 
732
        mc.priority = optarg;
 
733
        break;
 
734
      case '?':
 
735
      default:
 
736
        exit(EXIT_FAILURE);
754
737
      }
755
 
      /* Set the global debug flag from the temporary int */
756
 
      debug = debug_int ? true : false;
757
738
    }
 
739
    debug = debug_int ? true : false;
758
740
    
759
741
    pubkeyfile = combinepath(keydir, pubkeyfile);
760
742
    if (pubkeyfile == NULL){
761
743
      perror("combinepath");
762
 
      exitcode = EXIT_FAILURE;
763
 
      goto end;
 
744
      returncode = EXIT_FAILURE;
 
745
      goto exit;
764
746
    }
765
747
    
766
748
    seckeyfile = combinepath(keydir, seckeyfile);
767
749
    if (seckeyfile == NULL){
768
750
      perror("combinepath");
769
 
      goto end;
 
751
      goto exit;
770
752
    }
771
753
    
772
754
    if_index = (AvahiIfIndex) if_nametoindex(interface);
799
781
      }
800
782
    }
801
783
    
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);
 
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);
812
801
      if(ret == -1){
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);
 
802
        perror("ioctl SIOCSIFFLAGS");
 
803
        returncode = EXIT_FAILURE;
 
804
        goto exit;
 
805
      }
827
806
    }
 
807
    close(sd);
828
808
    
829
809
    if (not debug){
830
810
      avahi_set_log_function(empty_log);
831
811
    }
832
812
    
833
 
    /* Initialize the pseudo-RNG for Avahi */
 
813
    /* Initialize the psuedo-RNG */
834
814
    srand((unsigned int) time(NULL));
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",
 
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",
866
840
                avahi_strerror(error));
867
 
        exitcode = EXIT_FAILURE;
868
 
        goto end;
 
841
        returncode = EXIT_FAILURE;
 
842
        goto exit;
869
843
    }
870
844
    
871
 
    /* Create the Avahi service browser */
 
845
    /* Create the service browser */
872
846
    sb = avahi_s_service_browser_new(mc.server, if_index,
873
847
                                     AVAHI_PROTO_INET6,
874
848
                                     "_mandos._tcp", NULL, 0,
875
849
                                     browse_callback, &mc);
876
 
    if (sb == NULL) {
 
850
    if (!sb) {
877
851
        fprintf(stderr, "Failed to create service browser: %s\n",
878
852
                avahi_strerror(avahi_server_errno(mc.server)));
879
 
        exitcode = EXIT_FAILURE;
880
 
        goto end;
 
853
        returncode = EXIT_FAILURE;
 
854
        goto exit;
881
855
    }
882
856
    
883
857
    /* Run the main loop */
884
858
 
885
859
    if (debug){
886
 
      fprintf(stderr, "Starting Avahi loop search\n");
 
860
      fprintf(stderr, "Starting avahi loop search\n");
887
861
    }
888
862
    
889
863
    avahi_simple_poll_loop(mc.simple_poll);
890
864
    
891
 
 end:
 
865
 exit:
892
866
 
893
867
    if (debug){
894
868
      fprintf(stderr, "%s exiting\n", argv[0]);
895
869
    }
896
870
    
897
871
    /* Cleanup things */
898
 
    if (sb != NULL)
 
872
    if (sb)
899
873
        avahi_s_service_browser_free(sb);
900
874
    
901
 
    if (mc.server != NULL)
 
875
    if (mc.server)
902
876
        avahi_server_free(mc.server);
903
877
 
904
 
    if (mc.simple_poll != NULL)
 
878
    if (mc.simple_poll)
905
879
        avahi_simple_poll_free(mc.simple_poll);
906
880
    free(pubkeyfile);
907
881
    free(seckeyfile);
908
882
    
909
 
    return exitcode;
 
883
    return returncode;
910
884
}