/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: Björn Påhlsson
  • Date: 2008-07-31 16:20:47 UTC
  • mto: (237.7.1 mandos) (24.1.154 mandos)
  • mto: This revision was merged to the branch mainline in revision 30.
  • Revision ID: belorn@braxen-20080731162047-lahe2b2prwjw8b2l
plugbasedclient:
        Added support to disable plugins
        Added support to change plugin directory

mandosclient.c
        Fixed some funtion calls that lacked error handling
        small bugfix

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
48
48
#include <avahi-common/error.h>
49
49
 
50
50
//mandos client part
51
 
#include <sys/types.h>          /* socket(), setsockopt(),
52
 
                                   inet_pton() */
53
 
#include <sys/socket.h>         /* socket(), setsockopt(),
54
 
                                   struct sockaddr_in6,
 
51
#include <sys/types.h>          /* socket(), inet_pton() */
 
52
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
55
53
                                   struct in6_addr, inet_pton() */
56
54
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
57
55
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
70
68
// getopt long
71
69
#include <getopt.h>
72
70
 
73
 
#ifndef CERT_ROOT
74
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
75
 
#endif
76
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
77
 
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
78
71
#define BUFFER_SIZE 256
79
72
#define DH_BITS 1024
80
73
 
 
74
const char *certdir = "/conf/conf.d/cryptkeyreq/";
 
75
const char *certfile = "openpgp-client.txt";
 
76
const char *certkey = "openpgp-client-key.txt";
 
77
 
81
78
bool debug = false;
82
79
 
83
80
typedef struct {
103
100
  
104
101
  /* Init GPGME */
105
102
  gpgme_check_version(NULL);
106
 
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
103
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
104
  if (rc != GPG_ERR_NO_ERROR){
 
105
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
106
            gpgme_strsource(rc), gpgme_strerror(rc));
 
107
    return -1;
 
108
  }
107
109
  
108
110
  /* Set GPGME home directory */
109
111
  rc = gpgme_get_engine_info (&engine_info);
195
197
  gpgme_data_release(dh_crypto);
196
198
  
197
199
  /* Seek back to the beginning of the GPGME plaintext data buffer */
198
 
  gpgme_data_seek(dh_plain, 0, SEEK_SET);
199
 
 
 
200
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
201
    perror("pgpme_data_seek");
 
202
  }
 
203
  
200
204
  *new_packet = 0;
201
205
  while(true){
202
206
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
255
259
  if(debug){
256
260
    fprintf(stderr, "Initializing GnuTLS\n");
257
261
  }
258
 
  
 
262
 
259
263
  if ((ret = gnutls_global_init ())
260
264
      != GNUTLS_E_SUCCESS) {
261
265
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
277
281
  
278
282
  if(debug){
279
283
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
280
 
            " and keyfile %s as GnuTLS credentials\n", CERTFILE,
281
 
            KEYFILE);
 
284
            " and keyfile %s as GnuTLS credentials\n", certfile,
 
285
            certkey);
282
286
  }
283
287
  
284
288
  ret = gnutls_certificate_set_openpgp_key_file
285
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
 
289
    (es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
286
290
  if (ret != GNUTLS_E_SUCCESS) {
287
291
    fprintf
288
292
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
289
293
       " '%s')\n",
290
 
       ret, CERTFILE, KEYFILE);
 
294
       ret, certfile, certkey);
291
295
    fprintf(stdout, "The Error is: %s\n",
292
296
            safer_gnutls_strerror(ret));
293
297
    return -1;
345
349
void empty_log(__attribute__((unused)) AvahiLogLevel level,
346
350
               __attribute__((unused)) const char *txt){}
347
351
 
348
 
int start_mandos_communication(char *ip, uint16_t port,
 
352
int start_mandos_communication(const char *ip, uint16_t port,
349
353
                               unsigned int if_index){
350
354
  int ret, tcp_sd;
351
355
  struct sockaddr_in6 to;
355
359
  size_t buffer_length = 0;
356
360
  size_t buffer_capacity = 0;
357
361
  ssize_t decrypted_buffer_size;
 
362
  size_t written = 0;
358
363
  int retval = 0;
359
364
  char interface[IF_NAMESIZE];
360
365
  
379
384
    fprintf(stderr, "Binding to interface %s\n", interface);
380
385
  }
381
386
  
382
 
  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
383
 
  if(ret < 0) {
384
 
    perror("setsockopt bindtodevice");
385
 
    return -1;
386
 
  }
387
 
  
388
 
  memset(&to,0,sizeof(to));
 
387
  memset(&to,0,sizeof(to));     /* Spurious warning */
389
388
  to.sin6_family = AF_INET6;
390
389
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
391
390
  if (ret < 0 ){
396
395
    fprintf(stderr, "Bad address: %s\n", ip);
397
396
    return -1;
398
397
  }
399
 
  /* Spurious warnings for the next line, see for instance
400
 
     <http://bugs.debian.org/488884> */
401
 
  to.sin6_port = htons(port);
 
398
  to.sin6_port = htons(port);   /* Spurious warning */
402
399
  
403
400
  to.sin6_scope_id = (uint32_t)if_index;
404
401
  
428
425
  ret = gnutls_handshake (es.session);
429
426
  
430
427
  if (ret != GNUTLS_E_SUCCESS){
431
 
    fprintf(stderr, "\n*** Handshake failed ***\n");
432
 
    gnutls_perror (ret);
 
428
    if(debug){
 
429
      fprintf(stderr, "\n*** Handshake failed ***\n");
 
430
      gnutls_perror (ret);
 
431
    }
433
432
    retval = -1;
434
433
    goto exit;
435
434
  }
486
485
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
487
486
                                               buffer_length,
488
487
                                               &decrypted_buffer,
489
 
                                               CERT_ROOT);
 
488
                                               certdir);
490
489
    if (decrypted_buffer_size >= 0){
491
 
      while(decrypted_buffer_size > 0){
492
 
        ret = fwrite (decrypted_buffer, 1, (size_t)decrypted_buffer_size,
493
 
                      stdout);
 
490
      while(written < decrypted_buffer_size){
 
491
        ret = (int)fwrite (decrypted_buffer + written, 1,
 
492
                           (size_t)decrypted_buffer_size - written,
 
493
                           stdout);
494
494
        if(ret == 0 and ferror(stdout)){
495
495
          if(debug){
496
496
            fprintf(stderr, "Error writing encrypted data: %s\n",
499
499
          retval = -1;
500
500
          break;
501
501
        }
502
 
        decrypted_buffer += ret;
503
 
        decrypted_buffer_size -= ret;
 
502
        written += (size_t)ret;
504
503
      }
505
504
      free(decrypted_buffer);
506
505
    } else {
529
528
 
530
529
static void resolve_callback(
531
530
    AvahiSServiceResolver *r,
532
 
    AVAHI_GCC_UNUSED AvahiIfIndex interface,
 
531
    AvahiIfIndex interface,
533
532
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
534
533
    AvahiResolverEvent event,
535
534
    const char *name,
542
541
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
543
542
    AVAHI_GCC_UNUSED void* userdata) {
544
543
    
545
 
  assert(r);
546
 
 
 
544
  assert(r);                    /* Spurious warning */
 
545
  
547
546
  /* Called whenever a service has been resolved successfully or
548
547
     timed out */
549
 
 
 
548
  
550
549
  switch (event) {
551
550
  default:
552
551
  case AVAHI_RESOLVER_FAILURE:
554
553
            " type '%s' in domain '%s': %s\n", name, type, domain,
555
554
            avahi_strerror(avahi_server_errno(server)));
556
555
    break;
557
 
      
 
556
    
558
557
  case AVAHI_RESOLVER_FOUND:
559
558
    {
560
559
      char ip[AVAHI_ADDRESS_STR_MAX];
561
560
      avahi_address_snprint(ip, sizeof(ip), address);
562
561
      if(debug){
563
 
        fprintf(stderr, "Mandos server found on %s (%s) on port %d\n",
564
 
                host_name, ip, port);
 
562
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
 
563
                " port %d\n", name, host_name, ip, port);
565
564
      }
566
565
      int ret = start_mandos_communication(ip, port,
567
 
                                           (unsigned int)
568
 
                                           interface);
 
566
                                           (unsigned int) interface);
569
567
      if (ret == 0){
570
568
        exit(EXIT_SUCCESS);
571
 
      } else {
572
 
        exit(EXIT_FAILURE);
573
569
      }
574
570
    }
575
571
  }
588
584
    void* userdata) {
589
585
    
590
586
    AvahiServer *s = userdata;
591
 
    assert(b);
592
 
 
 
587
    assert(b);                  /* Spurious warning */
 
588
    
593
589
    /* Called whenever a new services becomes available on the LAN or
594
590
       is removed from the LAN */
595
 
 
 
591
    
596
592
    switch (event) {
597
593
    default:
598
594
    case AVAHI_BROWSER_FAILURE:
625
621
    }
626
622
}
627
623
 
 
624
/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */
 
625
const char *combinepath(const char *first, const char *second){
 
626
  char *tmp;
 
627
  tmp = malloc(strlen(first) + strlen(second) + 2);
 
628
  if (tmp == NULL){
 
629
    perror("malloc");
 
630
    return NULL;
 
631
  }
 
632
  strcpy(tmp, first);
 
633
  if (first[0] != '\0' and first[strlen(first) - 1] != '/'){
 
634
    strcat(tmp, "/");
 
635
  }
 
636
  strcat(tmp, second);
 
637
  return tmp;
 
638
}
 
639
 
 
640
 
628
641
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
629
642
    AvahiServerConfig config;
630
643
    AvahiSServiceBrowser *sb = NULL;
637
650
      static struct option long_options[] = {
638
651
        {"debug", no_argument, (int *)&debug, 1},
639
652
        {"interface", required_argument, 0, 'i'},
 
653
        {"certdir", required_argument, 0, 'd'},
 
654
        {"certkey", required_argument, 0, 'c'},
 
655
        {"certfile", required_argument, 0, 'k'},
640
656
        {0, 0, 0, 0} };
641
 
 
 
657
      
642
658
      int option_index = 0;
643
659
      ret = getopt_long (argc, argv, "i:", long_options,
644
660
                         &option_index);
645
 
 
 
661
      
646
662
      if (ret == -1){
647
663
        break;
648
664
      }
653
669
      case 'i':
654
670
        interface = optarg;
655
671
        break;
 
672
      case 'd':
 
673
        certdir = optarg;
 
674
        break;
 
675
      case 'c':
 
676
        certfile = optarg;
 
677
        break;
 
678
      case 'k':
 
679
        certkey = optarg;
 
680
        break;
656
681
      default:
657
682
        exit(EXIT_FAILURE);
658
683
      }
659
684
    }
 
685
 
 
686
    certfile = combinepath(certdir, certfile);
 
687
    if (certfile == NULL){
 
688
      goto exit;
 
689
    }
660
690
    
 
691
    certkey = combinepath(certdir, certkey);
 
692
    if (certkey == NULL){
 
693
      goto exit;
 
694
    }
 
695
        
661
696
    if (not debug){
662
697
      avahi_set_log_function(empty_log);
663
698
    }
731
766
 
732
767
    if (simple_poll)
733
768
        avahi_simple_poll_free(simple_poll);
734
 
 
 
769
    free(certfile);
 
770
    free(certkey);
 
771
    
735
772
    return returncode;
736
773
}