/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/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2008-09-30 07:23:39 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080930072339-jn15gyrtfpdk2dhx
* .bzrignore: Added "man" directory (created by "make install-html").

* Makefile: Add "common.ent" dependency to all manual pages.
  (htmldir, version, SED): New variables.
  (CFLAGS): Add -D option to define VERSION to $(version).
  (MANPOST, HTMLPOST): Use $(SED).
  (PROGS): Use $(CPROGS)
  (CPROGS): New; C-only programs.
  (objects): Use $(CPROGS).
  (common.ent, mandos, mandos-keygen): New targets; update version
                                       number to $(version).
  (clean): Use $(CPROGS).
  (check): Depend on "all".
  (install-html): Install to $(htmldir).

* common.ent: New file with "version" entity.

* mandos-clients.conf.xml: Use "common.ent".
* mandos-keygen.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
* plugin-runner.xml: - '' -
* plugins.d/mandos-client.xml: - '' -
* plugins.d/password-prompt.xml: - '' -

* plugin-runner.c (argp_program_version): Use VERSION.
* plugins.d/mandos-client.c (argp_program_version): - '' -
* plugins.d/password-prompt.c (argp_program_version): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
1
1
/*  -*- coding: utf-8 -*- */
2
2
/*
3
 
 * Mandos-client - get and decrypt data from a Mandos server
 
3
 * Mandos client - get and decrypt data from a Mandos server
4
4
 *
5
5
 * This program is partly derived from an example program for an Avahi
6
6
 * service browser, downloaded from
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008,2009 Teddy Hogeborn
13
 
 * Copyright © 2008,2009 Björn Påhlsson
 
12
 * Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
14
13
 * 
15
14
 * This program is free software: you can redistribute it and/or
16
15
 * modify it under the terms of the GNU General Public License as
36
35
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
37
36
 
38
37
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
39
 
                                   stdout, ferror(), sscanf */
 
38
                                   stdout, ferror() */
40
39
#include <stdint.h>             /* uint16_t, uint32_t */
41
40
#include <stddef.h>             /* NULL, size_t, ssize_t */
42
41
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
55
54
                                   connect() */
56
55
#include <fcntl.h>              /* open() */
57
56
#include <dirent.h>             /* opendir(), struct dirent, readdir() */
58
 
#include <inttypes.h>           /* PRIu16, SCNu16 */
 
57
#include <inttypes.h>           /* PRIu16 */
59
58
#include <assert.h>             /* assert() */
60
59
#include <errno.h>              /* perror(), errno */
61
60
#include <time.h>               /* time() */
67
66
                                   getuid(), getgid(), setuid(),
68
67
                                   setgid() */
69
68
#include <arpa/inet.h>          /* inet_pton(), htons */
70
 
#include <iso646.h>             /* not, and, or */
 
69
#include <iso646.h>             /* not, and */
71
70
#include <argp.h>               /* struct argp_option, error_t, struct
72
71
                                   argp_state, struct argp,
73
72
                                   argp_parse(), ARGP_KEY_ARG,
156
155
    int fd;
157
156
    gpgme_data_t pgp_data;
158
157
    
159
 
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
158
    fd = TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
160
159
    if(fd == -1){
161
160
      perror("open");
162
161
      return false;
176
175
      return false;
177
176
    }
178
177
    
179
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
178
    ret = TEMP_FAILURE_RETRY(close(fd));
180
179
    if(ret == -1){
181
180
      perror("close");
182
181
    }
501
500
                                      AvahiIfIndex if_index,
502
501
                                      mandos_context *mc){
503
502
  int ret, tcp_sd;
504
 
  ssize_t sret;
505
503
  union { struct sockaddr in; struct sockaddr_in6 in6; } to;
506
504
  char *buffer = NULL;
507
505
  char *decrypted_buffer;
578
576
  written = 0;
579
577
  while (true){
580
578
    size_t out_size = strlen(out);
581
 
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
 
579
    ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
582
580
                                   out_size - written));
583
581
    if (ret == -1){
584
582
      perror("write");
633
631
      goto mandos_end;
634
632
    }
635
633
    
636
 
    sret = gnutls_record_recv(session, buffer+buffer_length,
637
 
                              BUFFER_SIZE);
638
 
    if (sret == 0){
 
634
    ret = gnutls_record_recv(session, buffer+buffer_length,
 
635
                             BUFFER_SIZE);
 
636
    if (ret == 0){
639
637
      break;
640
638
    }
641
 
    if (sret < 0){
642
 
      switch(sret){
 
639
    if (ret < 0){
 
640
      switch(ret){
643
641
      case GNUTLS_E_INTERRUPTED:
644
642
      case GNUTLS_E_AGAIN:
645
643
        break;
662
660
        goto mandos_end;
663
661
      }
664
662
    } else {
665
 
      buffer_length += (size_t) sret;
 
663
      buffer_length += (size_t) ret;
666
664
    }
667
665
  }
668
666
  
704
702
  
705
703
 mandos_end:
706
704
  free(buffer);
707
 
  ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
705
  ret = TEMP_FAILURE_RETRY(close(tcp_sd));
708
706
  if(ret == -1){
709
707
    perror("close");
710
708
  }
866
864
      
867
865
      error_t parse_opt (int key, char *arg,
868
866
                         struct argp_state *state) {
 
867
        /* Get the INPUT argument from `argp_parse', which we know is
 
868
           a pointer to our plugin list pointer. */
869
869
        switch (key) {
870
870
        case 128:               /* --debug */
871
871
          debug = true;
883
883
          pubkey = arg;
884
884
          break;
885
885
        case 129:               /* --dh-bits */
886
 
          ret = sscanf(arg, "%u", &mc.dh_bits);
887
 
          if(ret == 0 or mc.dh_bits == 0){
888
 
            fprintf(stderr, "Bad number of DH bits\n");
 
886
          errno = 0;
 
887
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
 
888
          if (errno){
 
889
            perror("strtol");
889
890
            exit(EXIT_FAILURE);
890
891
          }
891
892
          break;
938
939
          goto end;
939
940
        }
940
941
      }
941
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
942
      ret = TEMP_FAILURE_RETRY(close(sd));
942
943
      if(ret == -1){
943
944
        perror("close");
944
945
      }
995
996
        exitcode = EXIT_FAILURE;
996
997
        goto end;
997
998
      }
998
 
      uint16_t port;
999
 
      ret = sscanf(address+1, "%" SCNu16, &port);
1000
 
      if(ret == 0 or port == 0){
1001
 
        fprintf(stderr, "Bad port number\n");
 
999
      errno = 0;
 
1000
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
 
1001
      if(errno){
 
1002
        perror("Bad port number");
1002
1003
        exitcode = EXIT_FAILURE;
1003
1004
        goto end;
1004
1005
      }
1107
1108
      struct dirent *direntry;
1108
1109
      d = opendir(tempdir);
1109
1110
      if(d == NULL){
1110
 
        if(errno != ENOENT){
1111
 
          perror("opendir");
1112
 
        }
 
1111
        perror("opendir");
1113
1112
      } else {
1114
1113
        while(true){
1115
1114
          direntry = readdir(d);
1135
1134
        closedir(d);
1136
1135
      }
1137
1136
      ret = rmdir(tempdir);
1138
 
      if(ret == -1 and errno != ENOENT){
 
1137
      if(ret == -1){
1139
1138
        perror("rmdir");
1140
1139
      }
1141
1140
    }