/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

not working midwork...

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
78
78
bool debug = false;
79
79
 
80
80
typedef struct {
81
 
  gnutls_session_t session;
 
81
  AvahiSimplePoll *simple_poll;
 
82
  AvahiServer *server;
82
83
  gnutls_certificate_credentials_t cred;
83
 
  gnutls_dh_params_t dh_params;
84
 
} encrypted_session;
85
 
 
 
84
  unsigned int dh_bits;
 
85
  const char *priority;
 
86
} mandos_context;
86
87
 
87
88
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
89
                                   char **new_packet,
253
254
  fprintf(stderr, "%s", string);
254
255
}
255
256
 
256
 
static int initgnutls(encrypted_session *es){
 
257
static int initgnutls(mandos_context *mc){
257
258
  const char *err;
258
259
  int ret;
259
260
  
322
323
            safer_gnutls_strerror(ret));
323
324
  }
324
325
  
325
 
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
 
326
  if ((ret = gnutls_priority_set_direct (es->session, mc->priority, &err))
326
327
      != GNUTLS_E_SUCCESS) {
327
328
    fprintf(stderr, "Syntax error at: %s\n", err);
328
329
    fprintf(stderr, "GnuTLS error: %s\n",
351
352
                      __attribute__((unused)) const char *txt){}
352
353
 
353
354
static int start_mandos_communication(const char *ip, uint16_t port,
354
 
                                      AvahiIfIndex if_index){
 
355
                                      AvahiIfIndex if_index,
 
356
                                      mandos_context *mc){
355
357
  int ret, tcp_sd;
356
358
  struct sockaddr_in6 to;
357
359
  encrypted_session es;
533
535
  return retval;
534
536
}
535
537
 
536
 
static AvahiSimplePoll *simple_poll = NULL;
537
 
static AvahiServer *server = NULL;
538
 
 
539
 
static void resolve_callback(
540
 
    AvahiSServiceResolver *r,
541
 
    AvahiIfIndex interface,
542
 
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
543
 
    AvahiResolverEvent event,
544
 
    const char *name,
545
 
    const char *type,
546
 
    const char *domain,
547
 
    const char *host_name,
548
 
    const AvahiAddress *address,
549
 
    uint16_t port,
550
 
    AVAHI_GCC_UNUSED AvahiStringList *txt,
551
 
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
552
 
    AVAHI_GCC_UNUSED void* userdata) {
553
 
    
 
538
static void resolve_callback( AvahiSServiceResolver *r,
 
539
                              AvahiIfIndex interface,
 
540
                              AVAHI_GCC_UNUSED AvahiProtocol protocol,
 
541
                              AvahiResolverEvent event,
 
542
                              const char *name,
 
543
                              const char *type,
 
544
                              const char *domain,
 
545
                              const char *host_name,
 
546
                              const AvahiAddress *address,
 
547
                              uint16_t port,
 
548
                              AVAHI_GCC_UNUSED AvahiStringList *txt,
 
549
                              AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
550
                              AVAHI_GCC_UNUSED void* userdata) {
 
551
  mandos_context *mc = userdata;
554
552
  assert(r);                    /* Spurious warning */
555
553
  
556
554
  /* Called whenever a service has been resolved successfully or
561
559
  case AVAHI_RESOLVER_FAILURE:
562
560
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
563
561
            " type '%s' in domain '%s': %s\n", name, type, domain,
564
 
            avahi_strerror(avahi_server_errno(server)));
 
562
            avahi_strerror(avahi_server_errno(mc->server)));
565
563
    break;
566
564
    
567
565
  case AVAHI_RESOLVER_FOUND:
572
570
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
573
571
                " port %d\n", name, host_name, ip, port);
574
572
      }
575
 
      int ret = start_mandos_communication(ip, port, interface);
 
573
      int ret = start_mandos_communication(ip, port, interface, mc);
576
574
      if (ret == 0){
577
575
        exit(EXIT_SUCCESS);
578
576
      }
581
579
  avahi_s_service_resolver_free(r);
582
580
}
583
581
 
584
 
static void browse_callback(
585
 
    AvahiSServiceBrowser *b,
586
 
    AvahiIfIndex interface,
587
 
    AvahiProtocol protocol,
588
 
    AvahiBrowserEvent event,
589
 
    const char *name,
590
 
    const char *type,
591
 
    const char *domain,
592
 
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
593
 
    void* userdata) {
594
 
    
595
 
    AvahiServer *s = userdata;
596
 
    assert(b);                  /* Spurious warning */
597
 
    
598
 
    /* Called whenever a new services becomes available on the LAN or
599
 
       is removed from the LAN */
600
 
    
601
 
    switch (event) {
602
 
    default:
603
 
    case AVAHI_BROWSER_FAILURE:
604
 
      
605
 
      fprintf(stderr, "(Browser) %s\n",
606
 
              avahi_strerror(avahi_server_errno(server)));
607
 
      avahi_simple_poll_quit(simple_poll);
608
 
      return;
609
 
      
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. */
615
 
      
616
 
      if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
617
 
                                         type, domain,
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)));
622
 
      break;
623
 
      
624
 
    case AVAHI_BROWSER_REMOVE:
625
 
      break;
626
 
      
627
 
    case AVAHI_BROWSER_ALL_FOR_NOW:
628
 
    case AVAHI_BROWSER_CACHE_EXHAUSTED:
629
 
      break;
630
 
    }
 
582
static void browse_callback( AvahiSServiceBrowser *b,
 
583
                             AvahiIfIndex interface,
 
584
                             AvahiProtocol protocol,
 
585
                             AvahiBrowserEvent event,
 
586
                             const char *name,
 
587
                             const char *type,
 
588
                             const char *domain,
 
589
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
590
                             void* userdata) {
 
591
  mandos_context *mc = userdata;
 
592
  assert(b);                    /* Spurious warning */
 
593
  
 
594
  /* Called whenever a new services becomes available on the LAN or
 
595
     is removed from the LAN */
 
596
  
 
597
  switch (event) {
 
598
  default:
 
599
  case AVAHI_BROWSER_FAILURE:
 
600
      
 
601
    fprintf(stderr, "(Browser) %s\n",
 
602
            avahi_strerror(avahi_server_errno(mc->server)));
 
603
    avahi_simple_poll_quit(mc->simple_poll);
 
604
    return;
 
605
      
 
606
  case AVAHI_BROWSER_NEW:
 
607
    /* We ignore the returned resolver object. In the callback
 
608
       function we free it. If the server is terminated before
 
609
       the callback function is called the server will free
 
610
       the resolver for us. */
 
611
      
 
612
    if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
 
613
                                       type, domain,
 
614
                                       AVAHI_PROTO_INET6, 0,
 
615
                                       resolve_callback, mc)))
 
616
      fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
 
617
              avahi_strerror(avahi_server_errno(s)));
 
618
    break;
 
619
      
 
620
  case AVAHI_BROWSER_REMOVE:
 
621
    break;
 
622
      
 
623
  case AVAHI_BROWSER_ALL_FOR_NOW:
 
624
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
625
    break;
 
626
  }
631
627
}
632
628
 
633
629
/* Combines file name and path and returns the malloced new
662
658
    int sd;
663
659
    char *connect_to = NULL;
664
660
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
661
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
662
                          .dh_bits = 2048, .priority = "SECURE256"};
665
663
    
666
664
    while (true){
667
665
      static struct option long_options[] = {
671
669
        {"certdir", required_argument, 0, 'd'},
672
670
        {"certkey", required_argument, 0, 'c'},
673
671
        {"certfile", required_argument, 0, 'k'},
 
672
        {"dh_bits", required_argument, 0, 'D'},
 
673
        {"priority", required_argument, 0, 'p'},
674
674
        {0, 0, 0, 0} };
675
675
      
676
676
      int option_index = 0;
699
699
      case 'k':
700
700
        certkey = optarg;
701
701
        break;
 
702
      case 'D':
 
703
        {
 
704
          long int tmp;
 
705
          errno = 0;
 
706
          tmp = strtol(optarg, NULL, 10);
 
707
          if (errno == ERANGE){
 
708
            perror("strtol");
 
709
            exit(EXIT_FAILURE);
 
710
          }
 
711
          mc.dh_bits = tmp;
 
712
        }
 
713
        break;
 
714
      case 'p':
 
715
        mc.priority = optarg;
 
716
        break;
702
717
      default:
703
718
        exit(EXIT_FAILURE);
704
719
      }
781
796
    srand((unsigned int) time(NULL));
782
797
 
783
798
    /* Allocate main loop object */
784
 
    if (!(simple_poll = avahi_simple_poll_new())) {
 
799
    if (!(mc.simple_poll = avahi_simple_poll_new())) {
785
800
        fprintf(stderr, "Failed to create simple poll object.\n");
786
801
        returncode = EXIT_FAILURE;      
787
802
        goto exit;
795
810
    config.publish_domain = 0;
796
811
 
797
812
    /* Allocate a new server */
798
 
    server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
813
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
799
814
                              &config, NULL, NULL, &error);
800
815
 
801
816
    /* Free the configuration data */
802
817
    avahi_server_config_free(&config);
803
818
 
804
819
    /* Check if creating the server object succeeded */
805
 
    if (!server) {
 
820
    if (!mc.server) {
806
821
        fprintf(stderr, "Failed to create server: %s\n",
807
822
                avahi_strerror(error));
808
823
        returncode = EXIT_FAILURE;
810
825
    }
811
826
    
812
827
    /* Create the service browser */
813
 
    sb = avahi_s_service_browser_new(server, if_index,
 
828
    sb = avahi_s_service_browser_new(mc.server, if_index,
814
829
                                     AVAHI_PROTO_INET6,
815
830
                                     "_mandos._tcp", NULL, 0,
816
 
                                     browse_callback, server);
 
831
                                     browse_callback, &mc);
817
832
    if (!sb) {
818
833
        fprintf(stderr, "Failed to create service browser: %s\n",
819
 
                avahi_strerror(avahi_server_errno(server)));
 
834
                avahi_strerror(avahi_server_errno(mc.server)));
820
835
        returncode = EXIT_FAILURE;
821
836
        goto exit;
822
837
    }
839
854
    if (sb)
840
855
        avahi_s_service_browser_free(sb);
841
856
    
842
 
    if (server)
843
 
        avahi_server_free(server);
 
857
    if (mc.server)
 
858
        avahi_server_free(mc.server);
844
859
 
845
860
    if (simple_poll)
846
861
        avahi_simple_poll_free(simple_poll);