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

  • Committer: Teddy Hogeborn
  • Date: 2008-12-10 01:26:02 UTC
  • mfrom: (237.1.2 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20081210012602-vhz3h75xkj24t340
First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
12
 * Copyright © 2008 Teddy Hogeborn
 
13
 * Copyright © 2008 Björn Påhlsson
13
14
 * 
14
15
 * This program is free software: you can redistribute it and/or
15
16
 * modify it under the terms of the GNU General Public License as
47
48
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
48
49
                                   sockaddr_in6, PF_INET6,
49
50
                                   SOCK_STREAM, INET6_ADDRSTRLEN,
50
 
                                   uid_t, gid_t */
51
 
#include <inttypes.h>           /* PRIu16 */
 
51
                                   uid_t, gid_t, open(), opendir(), DIR */
 
52
#include <sys/stat.h>           /* open() */
52
53
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
53
54
                                   struct in6_addr, inet_pton(),
54
55
                                   connect() */
 
56
#include <fcntl.h>              /* open() */
 
57
#include <dirent.h>             /* opendir(), struct dirent, readdir() */
 
58
#include <inttypes.h>           /* PRIu16 */
55
59
#include <assert.h>             /* assert() */
56
60
#include <errno.h>              /* perror(), errno */
57
61
#include <time.h>               /* time() */
58
62
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
59
63
                                   SIOCSIFFLAGS, if_indextoname(),
60
64
                                   if_nametoindex(), IF_NAMESIZE */
 
65
#include <netinet/in.h>
61
66
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
62
67
                                   getuid(), getgid(), setuid(),
63
68
                                   setgid() */
64
 
#include <netinet/in.h>
65
69
#include <arpa/inet.h>          /* inet_pton(), htons */
66
70
#include <iso646.h>             /* not, and */
67
71
#include <argp.h>               /* struct argp_option, error_t, struct
98
102
 
99
103
#define BUFFER_SIZE 256
100
104
 
 
105
#define PATHDIR "/conf/conf.d/mandos"
 
106
#define SECKEY "seckey.txt"
 
107
#define PUBKEY "pubkey.txt"
 
108
 
101
109
bool debug = false;
102
 
static const char *keydir = "/conf/conf.d/mandos";
103
110
static const char mandos_protocol_version[] = "1";
104
 
const char *argp_program_version = "password-request 1.0";
 
111
const char *argp_program_version = "mandos-client " VERSION;
105
112
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
106
113
 
107
114
/* Used for passing in values through the Avahi callback functions */
112
119
  unsigned int dh_bits;
113
120
  gnutls_dh_params_t dh_params;
114
121
  const char *priority;
 
122
  gpgme_ctx_t ctx;
115
123
} mandos_context;
116
124
 
117
125
/*
132
140
}
133
141
 
134
142
/* 
135
 
 * Decrypt OpenPGP data using keyrings in HOMEDIR.
136
 
 * Returns -1 on error
 
143
 * Initialize GPGME.
137
144
 */
138
 
static ssize_t pgp_packet_decrypt (const char *cryptotext,
139
 
                                   size_t crypto_size,
140
 
                                   char **plaintext,
141
 
                                   const char *homedir){
142
 
  gpgme_data_t dh_crypto, dh_plain;
143
 
  gpgme_ctx_t ctx;
 
145
static bool init_gpgme(mandos_context *mc, const char *seckey,
 
146
                       const char *pubkey, const char *tempdir){
 
147
  int ret;
144
148
  gpgme_error_t rc;
145
 
  ssize_t ret;
146
 
  size_t plaintext_capacity = 0;
147
 
  ssize_t plaintext_length = 0;
148
149
  gpgme_engine_info_t engine_info;
149
150
  
 
151
  
 
152
  /*
 
153
   * Helper function to insert pub and seckey to the enigne keyring.
 
154
   */
 
155
  bool import_key(const char *filename){
 
156
    int fd;
 
157
    gpgme_data_t pgp_data;
 
158
    
 
159
    fd = TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
160
    if(fd == -1){
 
161
      perror("open");
 
162
      return false;
 
163
    }
 
164
    
 
165
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
166
    if (rc != GPG_ERR_NO_ERROR){
 
167
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
168
              gpgme_strsource(rc), gpgme_strerror(rc));
 
169
      return false;
 
170
    }
 
171
    
 
172
    rc = gpgme_op_import(mc->ctx, pgp_data);
 
173
    if (rc != GPG_ERR_NO_ERROR){
 
174
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
 
175
              gpgme_strsource(rc), gpgme_strerror(rc));
 
176
      return false;
 
177
    }
 
178
    
 
179
    ret = TEMP_FAILURE_RETRY(close(fd));
 
180
    if(ret == -1){
 
181
      perror("close");
 
182
    }
 
183
    gpgme_data_release(pgp_data);
 
184
    return true;
 
185
  }
 
186
  
150
187
  if (debug){
151
 
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
188
    fprintf(stderr, "Initialize gpgme\n");
152
189
  }
153
190
  
154
191
  /* Init GPGME */
157
194
  if (rc != GPG_ERR_NO_ERROR){
158
195
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
159
196
            gpgme_strsource(rc), gpgme_strerror(rc));
160
 
    return -1;
 
197
    return false;
161
198
  }
162
199
  
163
 
  /* Set GPGME home directory for the OpenPGP engine only */
 
200
    /* Set GPGME home directory for the OpenPGP engine only */
164
201
  rc = gpgme_get_engine_info (&engine_info);
165
202
  if (rc != GPG_ERR_NO_ERROR){
166
203
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
167
204
            gpgme_strsource(rc), gpgme_strerror(rc));
168
 
    return -1;
 
205
    return false;
169
206
  }
170
207
  while(engine_info != NULL){
171
208
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
172
209
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
173
 
                            engine_info->file_name, homedir);
 
210
                            engine_info->file_name, tempdir);
174
211
      break;
175
212
    }
176
213
    engine_info = engine_info->next;
177
214
  }
178
215
  if(engine_info == NULL){
179
 
    fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
180
 
    return -1;
 
216
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
217
    return false;
 
218
  }
 
219
  
 
220
  /* Create new GPGME "context" */
 
221
  rc = gpgme_new(&(mc->ctx));
 
222
  if (rc != GPG_ERR_NO_ERROR){
 
223
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
224
            gpgme_strsource(rc), gpgme_strerror(rc));
 
225
    return false;
 
226
  }
 
227
  
 
228
  if (not import_key(pubkey) or not import_key(seckey)){
 
229
    return false;
 
230
  }
 
231
  
 
232
  return true; 
 
233
}
 
234
 
 
235
/* 
 
236
 * Decrypt OpenPGP data.
 
237
 * Returns -1 on error
 
238
 */
 
239
static ssize_t pgp_packet_decrypt (const mandos_context *mc,
 
240
                                   const char *cryptotext,
 
241
                                   size_t crypto_size,
 
242
                                   char **plaintext){
 
243
  gpgme_data_t dh_crypto, dh_plain;
 
244
  gpgme_error_t rc;
 
245
  ssize_t ret;
 
246
  size_t plaintext_capacity = 0;
 
247
  ssize_t plaintext_length = 0;
 
248
  
 
249
  if (debug){
 
250
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
181
251
  }
182
252
  
183
253
  /* Create new GPGME data buffer from memory cryptotext */
198
268
    return -1;
199
269
  }
200
270
  
201
 
  /* Create new GPGME "context" */
202
 
  rc = gpgme_new(&ctx);
203
 
  if (rc != GPG_ERR_NO_ERROR){
204
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
205
 
            gpgme_strsource(rc), gpgme_strerror(rc));
206
 
    plaintext_length = -1;
207
 
    goto decrypt_end;
208
 
  }
209
 
  
210
271
  /* Decrypt data from the cryptotext data buffer to the plaintext
211
272
     data buffer */
212
 
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
 
273
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
213
274
  if (rc != GPG_ERR_NO_ERROR){
214
275
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
215
276
            gpgme_strsource(rc), gpgme_strerror(rc));
216
277
    plaintext_length = -1;
217
278
    if (debug){
218
279
      gpgme_decrypt_result_t result;
219
 
      result = gpgme_op_decrypt_result(ctx);
 
280
      result = gpgme_op_decrypt_result(mc->ctx);
220
281
      if (result == NULL){
221
282
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
222
283
      } else {
251
312
  
252
313
  /* Seek back to the beginning of the GPGME plaintext data buffer */
253
314
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
254
 
    perror("pgpme_data_seek");
 
315
    perror("gpgme_data_seek");
255
316
    plaintext_length = -1;
256
317
    goto decrypt_end;
257
318
  }
281
342
    }
282
343
    plaintext_length += ret;
283
344
  }
284
 
 
 
345
  
285
346
  if(debug){
286
347
    fprintf(stderr, "Decrypted password is: ");
287
348
    for(ssize_t i = 0; i < plaintext_length; i++){
348
409
  }
349
410
  
350
411
  if(debug){
351
 
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
352
 
            " and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
 
412
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
413
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
353
414
            seckeyfilename);
354
415
  }
355
416
  
360
421
    fprintf(stderr,
361
422
            "Error[%d] while reading the OpenPGP key pair ('%s',"
362
423
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
363
 
    fprintf(stdout, "The GnuTLS error is: %s\n",
 
424
    fprintf(stderr, "The GnuTLS error is: %s\n",
364
425
            safer_gnutls_strerror(ret));
365
426
    goto globalfail;
366
427
  }
380
441
  }
381
442
  
382
443
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
383
 
 
 
444
  
384
445
  return 0;
385
 
 
 
446
  
386
447
 globalfail:
387
 
 
 
448
  
388
449
  gnutls_certificate_free_credentials(mc->cred);
389
450
  gnutls_global_deinit();
 
451
  gnutls_dh_params_deinit(mc->dh_params);
390
452
  return -1;
391
 
 
392
453
}
393
454
 
394
455
static int init_gnutls_session(mandos_context *mc,
466
527
    perror("socket");
467
528
    return -1;
468
529
  }
469
 
 
 
530
  
470
531
  if(debug){
471
532
    if(if_indextoname((unsigned int)if_index, interface) == NULL){
472
533
      perror("if_indextoname");
511
572
    perror("connect");
512
573
    return -1;
513
574
  }
514
 
 
 
575
  
515
576
  const char *out = mandos_protocol_version;
516
577
  written = 0;
517
578
  while (true){
535
596
      }
536
597
    }
537
598
  }
538
 
 
 
599
  
539
600
  if(debug){
540
601
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
541
602
  }
542
603
  
543
604
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
544
 
 
 
605
  
545
606
  do{
546
607
    ret = gnutls_handshake (session);
547
608
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
561
622
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
562
623
            ip);
563
624
  }
564
 
 
 
625
  
565
626
  while(true){
566
627
    buffer_capacity = adjustbuffer(&buffer, buffer_length,
567
628
                                   buffer_capacity);
611
672
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
612
673
  
613
674
  if (buffer_length > 0){
614
 
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
675
    decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
615
676
                                               buffer_length,
616
 
                                               &decrypted_buffer,
617
 
                                               keydir);
 
677
                                               &decrypted_buffer);
618
678
    if (decrypted_buffer_size >= 0){
619
679
      written = 0;
620
680
      while(written < (size_t) decrypted_buffer_size){
643
703
  
644
704
 mandos_end:
645
705
  free(buffer);
646
 
  close(tcp_sd);
 
706
  ret = TEMP_FAILURE_RETRY(close(tcp_sd));
 
707
  if(ret == -1){
 
708
    perror("close");
 
709
  }
647
710
  gnutls_deinit (session);
648
711
  return retval;
649
712
}
745
808
  }
746
809
}
747
810
 
748
 
/* Combines file name and path and returns the malloced new
749
 
   string. some sane checks could/should be added */
750
 
static char *combinepath(const char *first, const char *second){
751
 
  char *tmp;
752
 
  int ret = asprintf(&tmp, "%s/%s", first, second);
753
 
  if(ret < 0){
754
 
    return NULL;
755
 
  }
756
 
  return tmp;
757
 
}
758
 
 
759
 
 
760
811
int main(int argc, char *argv[]){
761
812
    AvahiSServiceBrowser *sb = NULL;
762
813
    int error;
768
819
    uid_t uid;
769
820
    gid_t gid;
770
821
    char *connect_to = NULL;
 
822
    char tempdir[] = "/tmp/mandosXXXXXX";
771
823
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
772
 
    char *pubkeyfilename = NULL;
773
 
    char *seckeyfilename = NULL;
774
 
    const char *pubkeyname = "pubkey.txt";
775
 
    const char *seckeyname = "seckey.txt";
 
824
    const char *seckey = PATHDIR "/" SECKEY;
 
825
    const char *pubkey = PATHDIR "/" PUBKEY;
 
826
    
776
827
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
777
 
                          .dh_bits = 1024, .priority = "SECURE256"};
 
828
                          .dh_bits = 1024, .priority = "SECURE256"
 
829
                          ":!CTYPE-X.509:+CTYPE-OPENPGP" };
778
830
    bool gnutls_initalized = false;
 
831
    bool gpgme_initalized = false;
779
832
    
780
833
    {
781
834
      struct argp_option options[] = {
782
835
        { .name = "debug", .key = 128,
783
836
          .doc = "Debug mode", .group = 3 },
784
837
        { .name = "connect", .key = 'c',
785
 
          .arg = "IP",
786
 
          .doc = "Connect directly to a sepcified mandos server",
 
838
          .arg = "ADDRESS:PORT",
 
839
          .doc = "Connect directly to a specific Mandos server",
787
840
          .group = 1 },
788
841
        { .name = "interface", .key = 'i',
789
 
          .arg = "INTERFACE",
790
 
          .doc = "Interface that Avahi will conntect through",
791
 
          .group = 1 },
792
 
        { .name = "keydir", .key = 'd',
793
 
          .arg = "KEYDIR",
794
 
          .doc = "Directory where the openpgp keyring is",
 
842
          .arg = "NAME",
 
843
          .doc = "Interface that will be used to search for Mandos"
 
844
          " servers",
795
845
          .group = 1 },
796
846
        { .name = "seckey", .key = 's',
797
 
          .arg = "SECKEY",
798
 
          .doc = "Secret openpgp key for gnutls authentication",
 
847
          .arg = "FILE",
 
848
          .doc = "OpenPGP secret key file base name",
799
849
          .group = 1 },
800
850
        { .name = "pubkey", .key = 'p',
801
 
          .arg = "PUBKEY",
802
 
          .doc = "Public openpgp key for gnutls authentication",
 
851
          .arg = "FILE",
 
852
          .doc = "OpenPGP public key file base name",
803
853
          .group = 2 },
804
854
        { .name = "dh-bits", .key = 129,
805
855
          .arg = "BITS",
806
 
          .doc = "dh-bits to use in gnutls communication",
 
856
          .doc = "Bit length of the prime number used in the"
 
857
          " Diffie-Hellman key exchange",
807
858
          .group = 2 },
808
859
        { .name = "priority", .key = 130,
809
 
          .arg = "PRIORITY",
810
 
          .doc = "GNUTLS priority", .group = 1 },
 
860
          .arg = "STRING",
 
861
          .doc = "GnuTLS priority string for the TLS handshake",
 
862
          .group = 1 },
811
863
        { .name = NULL }
812
864
      };
813
 
 
814
865
      
815
866
      error_t parse_opt (int key, char *arg,
816
867
                         struct argp_state *state) {
817
868
        /* Get the INPUT argument from `argp_parse', which we know is
818
869
           a pointer to our plugin list pointer. */
819
870
        switch (key) {
820
 
        case 128:
 
871
        case 128:               /* --debug */
821
872
          debug = true;
822
873
          break;
823
 
        case 'c':
 
874
        case 'c':               /* --connect */
824
875
          connect_to = arg;
825
876
          break;
826
 
        case 'i':
 
877
        case 'i':               /* --interface */
827
878
          interface = arg;
828
879
          break;
829
 
        case 'd':
830
 
          keydir = arg;
831
 
          break;
832
 
        case 's':
833
 
          seckeyname = arg;
834
 
          break;
835
 
        case 'p':
836
 
          pubkeyname = arg;
837
 
          break;
838
 
        case 129:
 
880
        case 's':               /* --seckey */
 
881
          seckey = arg;
 
882
          break;
 
883
        case 'p':               /* --pubkey */
 
884
          pubkey = arg;
 
885
          break;
 
886
        case 129:               /* --dh-bits */
839
887
          errno = 0;
840
888
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
841
889
          if (errno){
843
891
            exit(EXIT_FAILURE);
844
892
          }
845
893
          break;
846
 
        case 130:
 
894
        case 130:               /* --priority */
847
895
          mc.priority = arg;
848
896
          break;
849
897
        case ARGP_KEY_ARG:
855
903
        }
856
904
        return 0;
857
905
      }
858
 
 
 
906
      
859
907
      struct argp argp = { .options = options, .parser = parse_opt,
860
908
                           .args_doc = "",
861
909
                           .doc = "Mandos client -- Get and decrypt"
862
 
                           " passwords from mandos server" };
 
910
                           " passwords from a Mandos server" };
863
911
      ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
864
912
      if (ret == ARGP_ERR_UNKNOWN){
865
913
        fprintf(stderr, "Unknown error while parsing arguments\n");
867
915
        goto end;
868
916
      }
869
917
    }
870
 
      
871
 
    pubkeyfilename = combinepath(keydir, pubkeyname);
872
 
    if (pubkeyfilename == NULL){
873
 
      perror("combinepath");
874
 
      exitcode = EXIT_FAILURE;
875
 
      goto end;
876
 
    }
877
 
    
878
 
    seckeyfilename = combinepath(keydir, seckeyname);
879
 
    if (seckeyfilename == NULL){
880
 
      perror("combinepath");
881
 
      exitcode = EXIT_FAILURE;
882
 
      goto end;
883
 
    }
884
 
 
885
 
    ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
886
 
    if (ret == -1){
887
 
      fprintf(stderr, "init_gnutls_global failed\n");
888
 
      exitcode = EXIT_FAILURE;
889
 
      goto end;
890
 
    } else {
891
 
      gnutls_initalized = true;
892
 
    }
893
918
    
894
919
    /* If the interface is down, bring it up */
895
920
    {
915
940
          goto end;
916
941
        }
917
942
      }
918
 
      close(sd);
 
943
      ret = TEMP_FAILURE_RETRY(close(sd));
 
944
      if(ret == -1){
 
945
        perror("close");
 
946
      }
919
947
    }
920
948
    
921
949
    uid = getuid();
931
959
      perror("setgid");
932
960
    }
933
961
    
 
962
    ret = init_gnutls_global(&mc, pubkey, seckey);
 
963
    if (ret == -1){
 
964
      fprintf(stderr, "init_gnutls_global failed\n");
 
965
      exitcode = EXIT_FAILURE;
 
966
      goto end;
 
967
    } else {
 
968
      gnutls_initalized = true;
 
969
    }
 
970
    
 
971
    if(mkdtemp(tempdir) == NULL){
 
972
      perror("mkdtemp");
 
973
      tempdir[0] = '\0';
 
974
      goto end;
 
975
    }
 
976
    
 
977
    if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
 
978
      fprintf(stderr, "gpgme_initalized failed\n");
 
979
      exitcode = EXIT_FAILURE;
 
980
      goto end;
 
981
    } else {
 
982
      gpgme_initalized = true;
 
983
    }
 
984
    
934
985
    if_index = (AvahiIfIndex) if_nametoindex(interface);
935
986
    if(if_index == 0){
936
987
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
979
1030
        exitcode = EXIT_FAILURE;
980
1031
        goto end;
981
1032
    }
982
 
 
 
1033
    
983
1034
    {
984
1035
      AvahiServerConfig config;
985
1036
      /* Do not publish any local Zeroconf records */
988
1039
      config.publish_addresses = 0;
989
1040
      config.publish_workstation = 0;
990
1041
      config.publish_domain = 0;
991
 
 
 
1042
      
992
1043
      /* Allocate a new server */
993
1044
      mc.server = avahi_server_new(avahi_simple_poll_get
994
1045
                                   (mc.simple_poll), &config, NULL,
995
1046
                                   NULL, &error);
996
 
    
 
1047
      
997
1048
      /* Free the Avahi configuration data */
998
1049
      avahi_server_config_free(&config);
999
1050
    }
1019
1070
    }
1020
1071
    
1021
1072
    /* Run the main loop */
1022
 
 
 
1073
    
1023
1074
    if (debug){
1024
1075
      fprintf(stderr, "Starting Avahi loop search\n");
1025
1076
    }
1027
1078
    avahi_simple_poll_loop(mc.simple_poll);
1028
1079
    
1029
1080
 end:
1030
 
 
 
1081
    
1031
1082
    if (debug){
1032
1083
      fprintf(stderr, "%s exiting\n", argv[0]);
1033
1084
    }
1038
1089
    
1039
1090
    if (mc.server != NULL)
1040
1091
        avahi_server_free(mc.server);
1041
 
 
 
1092
    
1042
1093
    if (mc.simple_poll != NULL)
1043
1094
        avahi_simple_poll_free(mc.simple_poll);
1044
 
    free(pubkeyfilename);
1045
 
    free(seckeyfilename);
1046
 
 
 
1095
    
1047
1096
    if (gnutls_initalized){
1048
1097
      gnutls_certificate_free_credentials(mc.cred);
1049
1098
      gnutls_global_deinit ();
1050
 
    }
1051
 
    
 
1099
      gnutls_dh_params_deinit(mc.dh_params);
 
1100
    }
 
1101
    
 
1102
    if(gpgme_initalized){
 
1103
      gpgme_release(mc.ctx);
 
1104
    }
 
1105
    
 
1106
    /* Removes the temp directory used by GPGME */
 
1107
    if(tempdir[0] != '\0'){
 
1108
      DIR *d;
 
1109
      struct dirent *direntry;
 
1110
      d = opendir(tempdir);
 
1111
      if(d == NULL){
 
1112
        perror("opendir");
 
1113
      } else {
 
1114
        while(true){
 
1115
          direntry = readdir(d);
 
1116
          if(direntry == NULL){
 
1117
            break;
 
1118
          }
 
1119
          if (direntry->d_type == DT_REG){
 
1120
            char *fullname = NULL;
 
1121
            ret = asprintf(&fullname, "%s/%s", tempdir,
 
1122
                           direntry->d_name);
 
1123
            if(ret < 0){
 
1124
              perror("asprintf");
 
1125
              continue;
 
1126
            }
 
1127
            ret = unlink(fullname);
 
1128
            if(ret == -1){
 
1129
              fprintf(stderr, "unlink(\"%s\"): %s",
 
1130
                      fullname, strerror(errno));
 
1131
            }
 
1132
            free(fullname);
 
1133
          }
 
1134
        }
 
1135
        closedir(d);
 
1136
      }
 
1137
      ret = rmdir(tempdir);
 
1138
      if(ret == -1){
 
1139
        perror("rmdir");
 
1140
      }
 
1141
    }
 
1142
          
1052
1143
    return exitcode;
1053
1144
}