/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: Teddy Hogeborn
  • Date: 2008-08-02 10:48:24 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080802104824-fx0miwp9o4g9r31e
* plugbasedclient.c (struct process): New fields "eof", "completed",
                                      and "status".
  (handle_sigchld): New function.
  (main): Initialize "dir" to NULL to only closedir() it if necessary.
          Move "process_list" to be a global variable to be accessible
          by "handle_sigchld".  Make "handle_sigchld" handle SIGCHLD.
          Remove redundant check for NULL "dir".  Free "filename" when
          no longer used.  Block SIGCHLD around fork()/exec().
          Restore normal signals in child.  Only loop while running
          processes exist.  Print process buffer when the process is
          done and it has emitted EOF, not when it only emits EOF.
          Remove processes from list which exit non-cleanly.  In
          cleaning up, closedir() if necessary.  Bug fix: set next
          pointer correctly when freeing process list.

* plugins.d/passprompt.c (main): Do not ignore SIGQUIT.

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;
343
348
               __attribute__((unused)) const char *txt){}
344
349
 
345
350
int start_mandos_communication(const char *ip, uint16_t port,
346
 
                               unsigned int if_index){
 
351
                               AvahiIfIndex if_index){
347
352
  int ret, tcp_sd;
348
353
  struct sockaddr_in6 to;
349
354
  encrypted_session es;
367
372
    return -1;
368
373
  }
369
374
  
370
 
  if(if_indextoname(if_index, interface) == NULL){
 
375
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
371
376
    if(debug){
372
377
      perror("if_indextoname");
373
378
    }
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,
564
569
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
565
570
                " port %d\n", name, host_name, ip, port);
566
571
      }
567
 
      int ret = start_mandos_communication(ip, port,
568
 
                                           (unsigned int) interface);
 
572
      int ret = start_mandos_communication(ip, port, interface);
569
573
      if (ret == 0){
570
574
        exit(EXIT_SUCCESS);
571
575
      }
623
627
    }
624
628
}
625
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
 
626
647
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
627
648
    AvahiServerConfig config;
628
649
    AvahiSServiceBrowser *sb = NULL;
629
650
    int error;
630
651
    int ret;
631
652
    int returncode = EXIT_SUCCESS;
632
 
    const char *interface = "eth0";
633
 
    unsigned int if_index;
 
653
    const char *interface = NULL;
 
654
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
634
655
    char *connect_to = NULL;
635
656
    
636
657
    while (true){
637
658
      static struct option long_options[] = {
638
659
        {"debug", no_argument, (int *)&debug, 1},
639
 
        {"connect", required_argument, 0, 'c'},
 
660
        {"connect", required_argument, 0, 'C'},
640
661
        {"interface", required_argument, 0, 'i'},
 
662
        {"certdir", required_argument, 0, 'd'},
 
663
        {"certkey", required_argument, 0, 'c'},
 
664
        {"certfile", required_argument, 0, 'k'},
641
665
        {0, 0, 0, 0} };
642
666
      
643
667
      int option_index = 0;
654
678
      case 'i':
655
679
        interface = optarg;
656
680
        break;
 
681
      case 'C':
 
682
        connect_to = optarg;
 
683
        break;
 
684
      case 'd':
 
685
        certdir = optarg;
 
686
        break;
657
687
      case 'c':
658
 
        connect_to = optarg;
 
688
        certfile = optarg;
 
689
        break;
 
690
      case 'k':
 
691
        certkey = optarg;
659
692
        break;
660
693
      default:
661
694
        exit(EXIT_FAILURE);
662
695
      }
663
696
    }
 
697
 
 
698
    certfile = combinepath(certdir, certfile);
 
699
    if (certfile == NULL){
 
700
      goto exit;
 
701
    }
664
702
    
665
 
    if_index = if_nametoindex(interface);
666
 
    if(if_index == 0){
667
 
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
668
 
      exit(EXIT_FAILURE);
 
703
    if(interface != NULL){
 
704
      if_index = (AvahiIfIndex) if_nametoindex(interface);
 
705
      if(if_index == 0){
 
706
        fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
707
        exit(EXIT_FAILURE);
 
708
      }
669
709
    }
670
710
    
671
711
    if(connect_to != NULL){
692
732
      }
693
733
    }
694
734
    
 
735
    certkey = combinepath(certdir, certkey);
 
736
    if (certkey == NULL){
 
737
      goto exit;
 
738
    }
 
739
    
695
740
    if (not debug){
696
741
      avahi_set_log_function(empty_log);
697
742
    }
729
774
    }
730
775
    
731
776
    /* Create the service browser */
732
 
    sb = avahi_s_service_browser_new(server, (AvahiIfIndex)if_index,
 
777
    sb = avahi_s_service_browser_new(server, if_index,
733
778
                                     AVAHI_PROTO_INET6,
734
779
                                     "_mandos._tcp", NULL, 0,
735
780
                                     browse_callback, server);
763
808
 
764
809
    if (simple_poll)
765
810
        avahi_simple_poll_free(simple_poll);
766
 
 
 
811
    free(certfile);
 
812
    free(certkey);
 
813
    
767
814
    return returncode;
768
815
}