/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

mandosclient
        changed to argp

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
 
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
77
bool debug = false;
83
 
 
 
78
const char *keydir = "/conf/conf.d/mandos";
 
79
const char *argp_program_version = "mandosclient 0.9";
 
80
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
84
81
const char mandos_protocol_version[] = "1";
85
82
 
86
83
/* Used for passing in values through all the callback functions */
287
284
  fprintf(stderr, "GnuTLS: %s", string);
288
285
}
289
286
 
290
 
static int init_gnutls_global(mandos_context *mc){
 
287
static int init_gnutls_global(mandos_context *mc,
 
288
                              const char *pubkeyfile,
 
289
                              const char *seckeyfile){
291
290
  int ret;
292
291
  
293
292
  if(debug){
731
730
    gid_t gid;
732
731
    char *connect_to = NULL;
733
732
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
733
    const char *pubkeyfile = "pubkey.txt";
 
734
    const char *seckeyfile = "seckey.txt";
734
735
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
735
736
                          .dh_bits = 1024, .priority = "SECURE256"};
736
737
    
737
738
    {
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){
 
739
      struct argp_option options[] = {
 
740
        { .name = "debug", .key = 128,
 
741
          .doc = "Debug mode", .group = 3 },
 
742
        { .name = "connect", .key = 'c',
 
743
          .arg = "IP",
 
744
          .doc = "Connect directly to a sepcified mandos server", .group = 1 },
 
745
        { .name = "interface", .key = 'i',
 
746
          .arg = "INTERFACE",
 
747
          .doc = "Interface that Avahi will conntect through", .group = 1 },
 
748
        { .name = "keydir", .key = 'd',
 
749
          .arg = "KEYDIR",
 
750
          .doc = "Directory where the openpgp keyring is", .group = 1 },
 
751
        { .name = "seckey", .key = 's',
 
752
          .arg = "SECKEY",
 
753
          .doc = "Secret openpgp key for gnutls authentication", .group = 1 },
 
754
        { .name = "pubkey", .key = 'p',
 
755
          .arg = "PUBKEY",
 
756
          .doc = "Public openpgp key for gnutls authentication", .group = 2 },
 
757
        { .name = "dh-bits", .key = 129,
 
758
          .arg = "BITS",
 
759
          .doc = "dh-bits to use in gnutls communication", .group = 2 },
 
760
        { .name = "priority", .key = 130,
 
761
          .arg = "PRIORITY",
 
762
          .doc = "GNUTLS priority", .group = 1 },
 
763
        { .name = NULL }
 
764
      };
 
765
 
 
766
      
 
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. */
 
770
        switch (key) {
 
771
        case 128:
 
772
          debug = true;
757
773
          break;
758
 
        }
759
 
      
760
 
        switch(ret){
761
 
        case 0:
 
774
        case 'c':
 
775
          connect_to = arg;
762
776
          break;
763
777
        case 'i':
764
 
          interface = optarg;
765
 
          break;
766
 
        case 'c':
767
 
          connect_to = optarg;
 
778
          interface = arg;
768
779
          break;
769
780
        case 'd':
770
 
          keydir = optarg;
 
781
          keydir = arg;
 
782
          break;
 
783
        case 's':
 
784
          seckeyfile = arg;
771
785
          break;
772
786
        case 'p':
773
 
          pubkeyfile = optarg;
774
 
          break;
775
 
        case 's':
776
 
          seckeyfile = optarg;
777
 
          break;
778
 
        case 'D':
 
787
          pubkeyfile = arg;
 
788
          break;
 
789
        case 129:
779
790
          errno = 0;
780
 
          mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
 
791
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
781
792
          if (errno){
782
793
            perror("strtol");
783
794
            exit(EXIT_FAILURE);
784
795
          }
785
796
          break;
786
 
        case 'P':
787
 
          mc.priority = optarg;
788
 
          break;
789
 
        case '?':
 
797
        case 130:
 
798
          mc.priority = arg;
 
799
          break;
 
800
        case ARGP_KEY_ARG:
 
801
          argp_usage (state);
 
802
          break;
 
803
          case ARGP_KEY_END:
 
804
            break;
790
805
        default:
791
 
          /* getopt_long() has already printed a message about the
792
 
             unrcognized option, so just exit. */
793
 
          exit(EXIT_FAILURE);
 
806
          return ARGP_ERR_UNKNOWN;
794
807
        }
 
808
        return 0;
795
809
      }
796
 
      /* Set the global debug flag from the temporary int */
797
 
      debug = debug_int ? true : false;
 
810
 
 
811
      struct argp argp = { .options = options, .parser = parse_opt,
 
812
                           .args_doc = "",
 
813
                           .doc = "Mandos client -- Get and decrypt passwords from mandos server" };
 
814
      argp_parse (&argp, argc, argv, 0, 0, NULL);
798
815
    }
799
 
    
 
816
      
800
817
    pubkeyfile = combinepath(keydir, pubkeyfile);
801
818
    if (pubkeyfile == NULL){
802
819
      perror("combinepath");
810
827
      goto end;
811
828
    }
812
829
 
813
 
    ret = init_gnutls_global(&mc);
 
830
    ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
814
831
    if (ret == -1){
815
832
      fprintf(stderr, "init_gnutls_global\n");
816
833
      goto end;