/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

merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
75
75
#define BUFFER_SIZE 256
76
76
 
77
77
bool debug = false;
78
 
const char *keydir = "/conf/conf.d/mandos";
 
78
static const char *keydir = "/conf/conf.d/mandos";
79
79
const char *argp_program_version = "mandosclient 0.9";
80
80
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
81
 
const char mandos_protocol_version[] = "1";
 
81
static const char mandos_protocol_version[] = "1";
82
82
 
83
 
/* Used for passing in values through all the callback functions */
 
83
/* Used for passing in values through the Avahi callback functions */
84
84
typedef struct {
85
85
  AvahiSimplePoll *simple_poll;
86
86
  AvahiServer *server;
90
90
  const char *priority;
91
91
} mandos_context;
92
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. */
93
96
size_t adjustbuffer(char **buffer, size_t buffer_length,
94
97
                  size_t buffer_capacity){
95
98
  if (buffer_length + BUFFER_SIZE > buffer_capacity){
230
233
  
231
234
  *plaintext = NULL;
232
235
  while(true){
233
 
    plaintext_capacity = adjustbuffer(plaintext, (size_t)plaintext_length,
 
236
    plaintext_capacity = adjustbuffer(plaintext,
 
237
                                      (size_t)plaintext_length,
234
238
                                      plaintext_capacity);
235
239
    if (plaintext_capacity == 0){
236
240
        perror("adjustbuffer");
352
356
  return 0;
353
357
}
354
358
 
355
 
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){
356
361
  int ret;
357
362
  /* GnuTLS session creation */
358
363
  ret = gnutls_init(session, GNUTLS_SERVER);
398
403
                                      AvahiIfIndex if_index,
399
404
                                      mandos_context *mc){
400
405
  int ret, tcp_sd;
401
 
  struct sockaddr_in6 to;
 
406
  union { struct sockaddr in; struct sockaddr_in6 in6; } to;
402
407
  char *buffer = NULL;
403
408
  char *decrypted_buffer;
404
409
  size_t buffer_length = 0;
408
413
  int retval = 0;
409
414
  char interface[IF_NAMESIZE];
410
415
  gnutls_session_t session;
411
 
  gnutls_dh_params_t dh_params;
412
416
  
413
417
  ret = init_gnutls_session (mc, &session);
414
418
  if (ret != 0){
435
439
  }
436
440
  
437
441
  memset(&to,0,sizeof(to));     /* Spurious warning */
438
 
  to.sin6_family = AF_INET6;
 
442
  to.in6.sin6_family = AF_INET6;
439
443
  /* It would be nice to have a way to detect if we were passed an
440
444
     IPv4 address here.   Now we assume an IPv6 address. */
441
 
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
 
445
  ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
442
446
  if (ret < 0 ){
443
447
    perror("inet_pton");
444
448
    return -1;
447
451
    fprintf(stderr, "Bad address: %s\n", ip);
448
452
    return -1;
449
453
  }
450
 
  to.sin6_port = htons(port);   /* Spurious warning */
 
454
  to.in6.sin6_port = htons(port);       /* Spurious warning */
451
455
  
452
 
  to.sin6_scope_id = (uint32_t)if_index;
 
456
  to.in6.sin6_scope_id = (uint32_t)if_index;
453
457
  
454
458
  if(debug){
455
459
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
456
460
    char addrstr[INET6_ADDRSTRLEN] = "";
457
 
    if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
 
461
    if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
458
462
                 sizeof(addrstr)) == NULL){
459
463
      perror("inet_ntop");
460
464
    } else {
464
468
    }
465
469
  }
466
470
  
467
 
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
 
471
  ret = connect(tcp_sd, &to.in, sizeof(to));
468
472
  if (ret < 0){
469
473
    perror("connect");
470
474
    return -1;
519
523
  }
520
524
 
521
525
  while(true){
522
 
    buffer_capacity = adjustbuffer(&buffer, buffer_length, buffer_capacity);
 
526
    buffer_capacity = adjustbuffer(&buffer, buffer_length,
 
527
                                   buffer_capacity);
523
528
    if (buffer_capacity == 0){
524
529
      perror("adjustbuffer");
525
530
      retval = -1;
741
746
          .doc = "Debug mode", .group = 3 },
742
747
        { .name = "connect", .key = 'c',
743
748
          .arg = "IP",
744
 
          .doc = "Connect directly to a sepcified mandos server", .group = 1 },
 
749
          .doc = "Connect directly to a sepcified mandos server",
 
750
          .group = 1 },
745
751
        { .name = "interface", .key = 'i',
746
752
          .arg = "INTERFACE",
747
 
          .doc = "Interface that Avahi will conntect through", .group = 1 },
 
753
          .doc = "Interface that Avahi will conntect through",
 
754
          .group = 1 },
748
755
        { .name = "keydir", .key = 'd',
749
756
          .arg = "KEYDIR",
750
 
          .doc = "Directory where the openpgp keyring is", .group = 1 },
 
757
          .doc = "Directory where the openpgp keyring is",
 
758
          .group = 1 },
751
759
        { .name = "seckey", .key = 's',
752
760
          .arg = "SECKEY",
753
 
          .doc = "Secret openpgp key for gnutls authentication", .group = 1 },
 
761
          .doc = "Secret openpgp key for gnutls authentication",
 
762
          .group = 1 },
754
763
        { .name = "pubkey", .key = 'p',
755
764
          .arg = "PUBKEY",
756
 
          .doc = "Public openpgp key for gnutls authentication", .group = 2 },
 
765
          .doc = "Public openpgp key for gnutls authentication",
 
766
          .group = 2 },
757
767
        { .name = "dh-bits", .key = 129,
758
768
          .arg = "BITS",
759
 
          .doc = "dh-bits to use in gnutls communication", .group = 2 },
 
769
          .doc = "dh-bits to use in gnutls communication",
 
770
          .group = 2 },
760
771
        { .name = "priority", .key = 130,
761
772
          .arg = "PRIORITY",
762
773
          .doc = "GNUTLS priority", .group = 1 },
764
775
      };
765
776
 
766
777
      
767
 
      error_t parse_opt (int key, char *arg, struct argp_state *state) {
768
 
        /* Get the INPUT argument from `argp_parse', which we know is a
769
 
           pointer to our plugin list pointer. */
 
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. */
770
782
        switch (key) {
771
783
        case 128:
772
784
          debug = true;
810
822
 
811
823
      struct argp argp = { .options = options, .parser = parse_opt,
812
824
                           .args_doc = "",
813
 
                           .doc = "Mandos client -- Get and decrypt passwords from mandos server" };
 
825
                           .doc = "Mandos client -- Get and decrypt"
 
826
                           " passwords from mandos server" };
814
827
      argp_parse (&argp, argc, argv, 0, 0, NULL);
815
828
    }
816
829