/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-04 16:05:01 UTC
  • mfrom: (24.1.15 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20080804160501-woej7nf8amgrbc2e
* plugins.d/mandosclient.c (start_mandos_communication): Change "to"
                                    to be a union.  All users changed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
65
65
#include <arpa/inet.h>          /* inet_pton() */
66
66
#include <iso646.h>             /* not */
67
67
#include <net/if.h>             /* IF_NAMESIZE */
68
 
 
 
68
#include <argp.h>               /* struct argp_option,
 
69
                                   struct argp_state, struct argp,
 
70
                                   argp_parse() */
69
71
/* GPGME */
70
72
#include <errno.h>              /* perror() */
71
73
#include <gpgme.h>
72
74
 
73
 
/* getopt_long */
74
 
#include <getopt.h>
75
 
 
76
75
#define BUFFER_SIZE 256
77
76
 
 
77
bool debug = false;
78
78
static const char *keydir = "/conf/conf.d/mandos";
79
 
static const char *pubkeyfile = "pubkey.txt";
80
 
static const char *seckeyfile = "seckey.txt";
81
 
 
82
 
bool debug = false;
83
 
 
84
 
const char mandos_protocol_version[] = "1";
85
 
 
86
 
/* Used for passing in values through all the callback functions */
 
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";
 
82
 
 
83
/* Used for passing in values through the Avahi callback functions */
87
84
typedef struct {
88
85
  AvahiSimplePoll *simple_poll;
89
86
  AvahiServer *server;
93
90
  const char *priority;
94
91
} mandos_context;
95
92
 
 
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
96
size_t adjustbuffer(char **buffer, size_t buffer_length,
97
97
                  size_t buffer_capacity){
98
98
  if (buffer_length + BUFFER_SIZE > buffer_capacity){
233
233
  
234
234
  *plaintext = NULL;
235
235
  while(true){
236
 
    plaintext_capacity = adjustbuffer(plaintext, (size_t)plaintext_length,
 
236
    plaintext_capacity = adjustbuffer(plaintext,
 
237
                                      (size_t)plaintext_length,
237
238
                                      plaintext_capacity);
238
239
    if (plaintext_capacity == 0){
239
240
        perror("adjustbuffer");
287
288
  fprintf(stderr, "GnuTLS: %s", string);
288
289
}
289
290
 
290
 
static int init_gnutls_global(mandos_context *mc){
 
291
static int init_gnutls_global(mandos_context *mc,
 
292
                              const char *pubkeyfile,
 
293
                              const char *seckeyfile){
291
294
  int ret;
292
295
  
293
296
  if(debug){
353
356
  return 0;
354
357
}
355
358
 
356
 
static int init_gnutls_session(mandos_context *mc, gnutls_session_t *session){
 
359
static int init_gnutls_session(mandos_context *mc,
 
360
                               gnutls_session_t *session){
357
361
  int ret;
358
362
  /* GnuTLS session creation */
359
363
  ret = gnutls_init(session, GNUTLS_SERVER);
399
403
                                      AvahiIfIndex if_index,
400
404
                                      mandos_context *mc){
401
405
  int ret, tcp_sd;
402
 
  struct sockaddr_in6 to;
 
406
  union { struct sockaddr in; struct sockaddr_in6 in6; } to;
403
407
  char *buffer = NULL;
404
408
  char *decrypted_buffer;
405
409
  size_t buffer_length = 0;
409
413
  int retval = 0;
410
414
  char interface[IF_NAMESIZE];
411
415
  gnutls_session_t session;
412
 
  gnutls_dh_params_t dh_params;
413
416
  
414
417
  ret = init_gnutls_session (mc, &session);
415
418
  if (ret != 0){
436
439
  }
437
440
  
438
441
  memset(&to,0,sizeof(to));     /* Spurious warning */
439
 
  to.sin6_family = AF_INET6;
 
442
  to.in6.sin6_family = AF_INET6;
440
443
  /* It would be nice to have a way to detect if we were passed an
441
444
     IPv4 address here.   Now we assume an IPv6 address. */
442
 
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
 
445
  ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
443
446
  if (ret < 0 ){
444
447
    perror("inet_pton");
445
448
    return -1;
448
451
    fprintf(stderr, "Bad address: %s\n", ip);
449
452
    return -1;
450
453
  }
451
 
  to.sin6_port = htons(port);   /* Spurious warning */
 
454
  to.in6.sin6_port = htons(port);       /* Spurious warning */
452
455
  
453
 
  to.sin6_scope_id = (uint32_t)if_index;
 
456
  to.in6.sin6_scope_id = (uint32_t)if_index;
454
457
  
455
458
  if(debug){
456
459
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
457
460
    char addrstr[INET6_ADDRSTRLEN] = "";
458
 
    if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
 
461
    if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
459
462
                 sizeof(addrstr)) == NULL){
460
463
      perror("inet_ntop");
461
464
    } else {
465
468
    }
466
469
  }
467
470
  
468
 
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
 
471
  ret = connect(tcp_sd, &to.in, sizeof(to));
469
472
  if (ret < 0){
470
473
    perror("connect");
471
474
    return -1;
520
523
  }
521
524
 
522
525
  while(true){
523
 
    buffer_capacity = adjustbuffer(&buffer, buffer_length, buffer_capacity);
 
526
    buffer_capacity = adjustbuffer(&buffer, buffer_length,
 
527
                                   buffer_capacity);
524
528
    if (buffer_capacity == 0){
525
529
      perror("adjustbuffer");
526
530
      retval = -1;
731
735
    gid_t gid;
732
736
    char *connect_to = NULL;
733
737
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
738
    const char *pubkeyfile = "pubkey.txt";
 
739
    const char *seckeyfile = "seckey.txt";
734
740
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
735
741
                          .dh_bits = 1024, .priority = "SECURE256"};
736
742
    
737
743
    {
738
 
      /* Temporary int to get the address of for getopt_long */
739
 
      int debug_int = debug ? 1 : 0;
740
 
      while (true){
741
 
        struct option long_options[] = {
742
 
          {"debug", no_argument, &debug_int, 1},
743
 
          {"connect", required_argument, NULL, 'c'},
744
 
          {"interface", required_argument, NULL, 'i'},
745
 
          {"keydir", required_argument, NULL, 'd'},
746
 
          {"seckey", required_argument, NULL, 's'},
747
 
          {"pubkey", required_argument, NULL, 'p'},
748
 
          {"dh-bits", required_argument, NULL, 'D'},
749
 
          {"priority", required_argument, NULL, 'P'},
750
 
          {0, 0, 0, 0} };
751
 
      
752
 
        int option_index = 0;
753
 
        ret = getopt_long (argc, argv, "i:", long_options,
754
 
                           &option_index);
755
 
      
756
 
        if (ret == -1){
 
744
      struct argp_option options[] = {
 
745
        { .name = "debug", .key = 128,
 
746
          .doc = "Debug mode", .group = 3 },
 
747
        { .name = "connect", .key = 'c',
 
748
          .arg = "IP",
 
749
          .doc = "Connect directly to a sepcified mandos server",
 
750
          .group = 1 },
 
751
        { .name = "interface", .key = 'i',
 
752
          .arg = "INTERFACE",
 
753
          .doc = "Interface that Avahi will conntect through",
 
754
          .group = 1 },
 
755
        { .name = "keydir", .key = 'd',
 
756
          .arg = "KEYDIR",
 
757
          .doc = "Directory where the openpgp keyring is",
 
758
          .group = 1 },
 
759
        { .name = "seckey", .key = 's',
 
760
          .arg = "SECKEY",
 
761
          .doc = "Secret openpgp key for gnutls authentication",
 
762
          .group = 1 },
 
763
        { .name = "pubkey", .key = 'p',
 
764
          .arg = "PUBKEY",
 
765
          .doc = "Public openpgp key for gnutls authentication",
 
766
          .group = 2 },
 
767
        { .name = "dh-bits", .key = 129,
 
768
          .arg = "BITS",
 
769
          .doc = "dh-bits to use in gnutls communication",
 
770
          .group = 2 },
 
771
        { .name = "priority", .key = 130,
 
772
          .arg = "PRIORITY",
 
773
          .doc = "GNUTLS priority", .group = 1 },
 
774
        { .name = NULL }
 
775
      };
 
776
 
 
777
      
 
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. */
 
782
        switch (key) {
 
783
        case 128:
 
784
          debug = true;
757
785
          break;
758
 
        }
759
 
      
760
 
        switch(ret){
761
 
        case 0:
 
786
        case 'c':
 
787
          connect_to = arg;
762
788
          break;
763
789
        case 'i':
764
 
          interface = optarg;
765
 
          break;
766
 
        case 'c':
767
 
          connect_to = optarg;
 
790
          interface = arg;
768
791
          break;
769
792
        case 'd':
770
 
          keydir = optarg;
 
793
          keydir = arg;
 
794
          break;
 
795
        case 's':
 
796
          seckeyfile = arg;
771
797
          break;
772
798
        case 'p':
773
 
          pubkeyfile = optarg;
774
 
          break;
775
 
        case 's':
776
 
          seckeyfile = optarg;
777
 
          break;
778
 
        case 'D':
 
799
          pubkeyfile = arg;
 
800
          break;
 
801
        case 129:
779
802
          errno = 0;
780
 
          mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
 
803
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
781
804
          if (errno){
782
805
            perror("strtol");
783
806
            exit(EXIT_FAILURE);
784
807
          }
785
808
          break;
786
 
        case 'P':
787
 
          mc.priority = optarg;
788
 
          break;
789
 
        case '?':
 
809
        case 130:
 
810
          mc.priority = arg;
 
811
          break;
 
812
        case ARGP_KEY_ARG:
 
813
          argp_usage (state);
 
814
          break;
 
815
          case ARGP_KEY_END:
 
816
            break;
790
817
        default:
791
 
          /* getopt_long() has already printed a message about the
792
 
             unrcognized option, so just exit. */
793
 
          exit(EXIT_FAILURE);
 
818
          return ARGP_ERR_UNKNOWN;
794
819
        }
 
820
        return 0;
795
821
      }
796
 
      /* Set the global debug flag from the temporary int */
797
 
      debug = debug_int ? true : false;
 
822
 
 
823
      struct argp argp = { .options = options, .parser = parse_opt,
 
824
                           .args_doc = "",
 
825
                           .doc = "Mandos client -- Get and decrypt"
 
826
                           " passwords from mandos server" };
 
827
      argp_parse (&argp, argc, argv, 0, 0, NULL);
798
828
    }
799
 
    
 
829
      
800
830
    pubkeyfile = combinepath(keydir, pubkeyfile);
801
831
    if (pubkeyfile == NULL){
802
832
      perror("combinepath");
810
840
      goto end;
811
841
    }
812
842
 
813
 
    ret = init_gnutls_global(&mc);
 
843
    ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
814
844
    if (ret == -1){
815
845
      fprintf(stderr, "init_gnutls_global\n");
816
846
      goto end;