/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-01 06:33:15 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080801063315-4k33q3ek28hjc3tu
* plugins.d/plugbasedclient.c: Update include file comments.
  (struct process.disable): Renamed to "disabled".  All users changed.
  (addarguments): Renamed to "addargument".  All callers changed.
  (doc, args_doc): Removed.
  (main): Changed default "plugindir" to
          "/conf/conf.d/mandos/plugins.d".  Renamed "rfds_orig" to
           "rfds_all"; all users changed.  New "debug" and
           "exitstatus" variables.  New "--debug" option.  Removed
           unnecessary ".flags = 0" from all options.  Changed so that
           "--disable-plugin" only takes one plugin.  Check for
           non-existence of ":" in argument to "--options-for".  Added
           some debugging outputs.  Set the FD_CLOEXEC flag on the
           directory FD.  More capable code for dealing with
           disallowed plugin file name prefixes and suffixes.  Bug
           fix: check for some malloc failures.  Moved allocating the
           "struct process *new_process" to after the fork.  Do
           _exit() instead of exit() in the child.

* plugins.d/mandosclient.c: Updated contact information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
25
25
 * along with this program.  If not, see
26
26
 * <http://www.gnu.org/licenses/>.
27
27
 * 
28
 
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
29
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
28
 * Contact the authors at <mandos@fukt.bsnet.se>.
30
29
 */
31
30
 
32
31
/* Needed by GPGME, specifically gpgme_data_seek() */
67
66
// getopt long
68
67
#include <getopt.h>
69
68
 
70
 
#ifndef CERT_ROOT
71
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
72
 
#endif
73
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
74
 
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
75
69
#define BUFFER_SIZE 256
76
70
#define DH_BITS 1024
77
71
 
 
72
const char *certdir = "/conf/conf.d/cryptkeyreq/";
 
73
const char *certfile = "openpgp-client.txt";
 
74
const char *certkey = "openpgp-client-key.txt";
 
75
 
78
76
bool debug = false;
79
77
 
80
78
typedef struct {
100
98
  
101
99
  /* Init GPGME */
102
100
  gpgme_check_version(NULL);
103
 
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
101
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
102
  if (rc != GPG_ERR_NO_ERROR){
 
103
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
104
            gpgme_strsource(rc), gpgme_strerror(rc));
 
105
    return -1;
 
106
  }
104
107
  
105
108
  /* Set GPGME home directory */
106
109
  rc = gpgme_get_engine_info (&engine_info);
192
195
  gpgme_data_release(dh_crypto);
193
196
  
194
197
  /* Seek back to the beginning of the GPGME plaintext data buffer */
195
 
  gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
196
 
 
 
198
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
199
    perror("pgpme_data_seek");
 
200
  }
 
201
  
197
202
  *new_packet = 0;
198
203
  while(true){
199
204
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
252
257
  if(debug){
253
258
    fprintf(stderr, "Initializing GnuTLS\n");
254
259
  }
255
 
  
 
260
 
256
261
  if ((ret = gnutls_global_init ())
257
262
      != GNUTLS_E_SUCCESS) {
258
263
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
274
279
  
275
280
  if(debug){
276
281
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
277
 
            " and keyfile %s as GnuTLS credentials\n", CERTFILE,
278
 
            KEYFILE);
 
282
            " and keyfile %s as GnuTLS credentials\n", certfile,
 
283
            certkey);
279
284
  }
280
285
  
281
286
  ret = gnutls_certificate_set_openpgp_key_file
282
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
 
287
    (es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
283
288
  if (ret != GNUTLS_E_SUCCESS) {
284
289
    fprintf
285
290
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
286
291
       " '%s')\n",
287
 
       ret, CERTFILE, KEYFILE);
 
292
       ret, certfile, certkey);
288
293
    fprintf(stdout, "The Error is: %s\n",
289
294
            safer_gnutls_strerror(ret));
290
295
    return -1;
487
492
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
488
493
                                               buffer_length,
489
494
                                               &decrypted_buffer,
490
 
                                               CERT_ROOT);
 
495
                                               certdir);
491
496
    if (decrypted_buffer_size >= 0){
492
497
      while(written < (size_t) decrypted_buffer_size){
493
498
        ret = (int)fwrite (decrypted_buffer + written, 1,
622
627
    }
623
628
}
624
629
 
 
630
/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */
 
631
const char *combinepath(const char *first, const char *second){
 
632
  char *tmp;
 
633
  tmp = malloc(strlen(first) + strlen(second) + 2);
 
634
  if (tmp == NULL){
 
635
    perror("malloc");
 
636
    return NULL;
 
637
  }
 
638
  strcpy(tmp, first);
 
639
  if (first[0] != '\0' and first[strlen(first) - 1] != '/'){
 
640
    strcat(tmp, "/");
 
641
  }
 
642
  strcat(tmp, second);
 
643
  return tmp;
 
644
}
 
645
 
 
646
 
625
647
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
626
648
    AvahiServerConfig config;
627
649
    AvahiSServiceBrowser *sb = NULL;
635
657
    while (true){
636
658
      static struct option long_options[] = {
637
659
        {"debug", no_argument, (int *)&debug, 1},
638
 
        {"connect", required_argument, 0, 'c'},
 
660
        {"connect", required_argument, 0, 'C'},
639
661
        {"interface", required_argument, 0, 'i'},
 
662
        {"certdir", required_argument, 0, 'd'},
 
663
        {"certkey", required_argument, 0, 'c'},
 
664
        {"certfile", required_argument, 0, 'k'},
640
665
        {0, 0, 0, 0} };
641
666
      
642
667
      int option_index = 0;
653
678
      case 'i':
654
679
        interface = optarg;
655
680
        break;
 
681
      case 'C':
 
682
        connect_to = optarg;
 
683
        break;
 
684
      case 'd':
 
685
        certdir = optarg;
 
686
        break;
656
687
      case 'c':
657
 
        connect_to = optarg;
 
688
        certfile = optarg;
 
689
        break;
 
690
      case 'k':
 
691
        certkey = optarg;
658
692
        break;
659
693
      default:
660
694
        exit(EXIT_FAILURE);
661
695
      }
662
696
    }
 
697
 
 
698
    certfile = combinepath(certdir, certfile);
 
699
    if (certfile == NULL){
 
700
      goto exit;
 
701
    }
663
702
    
664
703
    if(interface != NULL){
665
704
      if_index = (AvahiIfIndex) if_nametoindex(interface);
693
732
      }
694
733
    }
695
734
    
 
735
    certkey = combinepath(certdir, certkey);
 
736
    if (certkey == NULL){
 
737
      goto exit;
 
738
    }
 
739
    
696
740
    if (not debug){
697
741
      avahi_set_log_function(empty_log);
698
742
    }
764
808
 
765
809
    if (simple_poll)
766
810
        avahi_simple_poll_free(simple_poll);
767
 
 
 
811
    free(certfile);
 
812
    free(certkey);
 
813
    
768
814
    return returncode;
769
815
}