/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

Merge from Björn:

* plugin-runner.c (main): Bug fix: For the "--options-for" option, do
                          not mangle arguments with colon characters.
                          Also support adding empty arguments.

* plugins.d/mandos-client.c: (mc): New global variable; moved from
                                   "main".
  (init_gpgme, pgp_packet_decrypt, init_gnutls_global,
  init_gnutls_session, start_mandos_communication): Removed "mc"
                                                    argument.  All
                                                    callers changed.

  (resolve_callback, browse_callback): Ignore "userdata" argument.
                                       All callers changed.
  (handle_sigterm): New function.
  (main): Add "handle_sigterm" as signal handler for SIGTERM before
          starting the main loop.

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
8
8
 * includes the following functions: "resolve_callback",
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
 
 * Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
12
 
 * Påhlsson.
 
11
 * Everything else is
 
12
 * Copyright © 2008,2009 Teddy Hogeborn
 
13
 * Copyright © 2008,2009 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
25
26
 * along with this program.  If not, see
26
27
 * <http://www.gnu.org/licenses/>.
27
28
 * 
28
 
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
29
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
29
 * Contact the authors at <mandos@fukt.bsnet.se>.
30
30
 */
31
31
 
32
 
#define _FORTIFY_SOURCE 2
33
 
 
 
32
/* Needed by GPGME, specifically gpgme_data_seek() */
34
33
#define _LARGEFILE_SOURCE
35
34
#define _FILE_OFFSET_BITS 64
36
35
 
37
 
#include <stdio.h>
38
 
#include <assert.h>
39
 
#include <stdlib.h>
40
 
#include <time.h>
41
 
#include <net/if.h>             /* if_nametoindex */
42
 
 
 
36
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
 
37
 
 
38
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
 
39
                                   stdout, ferror(), sscanf(),
 
40
                                   remove() */
 
41
#include <stdint.h>             /* uint16_t, uint32_t */
 
42
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
43
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
 
44
                                   srand() */
 
45
#include <stdbool.h>            /* bool, false, true */
 
46
#include <string.h>             /* memset(), strcmp(), strlen(),
 
47
                                   strerror(), asprintf(), strcpy() */
 
48
#include <sys/ioctl.h>          /* ioctl */
 
49
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
 
50
                                   sockaddr_in6, PF_INET6,
 
51
                                   SOCK_STREAM, uid_t, gid_t, open(),
 
52
                                   opendir(), DIR */
 
53
#include <sys/stat.h>           /* open() */
 
54
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
55
                                   inet_pton(), connect() */
 
56
#include <fcntl.h>              /* open() */
 
57
#include <dirent.h>             /* opendir(), struct dirent, readdir()
 
58
                                 */
 
59
#include <inttypes.h>           /* PRIu16, intmax_t, SCNdMAX */
 
60
#include <assert.h>             /* assert() */
 
61
#include <errno.h>              /* perror(), errno */
 
62
#include <time.h>               /* nanosleep(), time() */
 
63
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
 
64
                                   SIOCSIFFLAGS, if_indextoname(),
 
65
                                   if_nametoindex(), IF_NAMESIZE */
 
66
#include <netinet/in.h>         /* IN6_IS_ADDR_LINKLOCAL,
 
67
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
 
68
                                */
 
69
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
 
70
                                   getuid(), getgid(), setuid(),
 
71
                                   setgid() */
 
72
#include <arpa/inet.h>          /* inet_pton(), htons */
 
73
#include <iso646.h>             /* not, or, and */
 
74
#include <argp.h>               /* struct argp_option, error_t, struct
 
75
                                   argp_state, struct argp,
 
76
                                   argp_parse(), ARGP_KEY_ARG,
 
77
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
 
78
#include <signal.h>             /* sigemptyset(), sigaddset(),
 
79
                                   sigaction(), SIGTERM, sigaction */
 
80
 
 
81
#ifdef __linux__
 
82
#include <sys/klog.h>           /* klogctl() */
 
83
#endif
 
84
 
 
85
/* Avahi */
 
86
/* All Avahi types, constants and functions
 
87
 Avahi*, avahi_*,
 
88
 AVAHI_* */
43
89
#include <avahi-core/core.h>
44
90
#include <avahi-core/lookup.h>
45
91
#include <avahi-core/log.h>
47
93
#include <avahi-common/malloc.h>
48
94
#include <avahi-common/error.h>
49
95
 
50
 
//mandos client part
51
 
#include <sys/types.h>          /* socket(), inet_pton() */
52
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
53
 
                                   struct in6_addr, inet_pton() */
54
 
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
55
 
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
56
 
 
57
 
#include <unistd.h>             /* close() */
58
 
#include <netinet/in.h>
59
 
#include <stdbool.h>            /* true */
60
 
#include <string.h>             /* memset */
61
 
#include <arpa/inet.h>          /* inet_pton() */
62
 
#include <iso646.h>             /* not */
63
 
 
64
 
// gpgme
65
 
#include <errno.h>              /* perror() */
66
 
#include <gpgme.h>
67
 
 
68
 
// getopt long
69
 
#include <getopt.h>
70
 
 
71
 
#ifndef CERT_ROOT
72
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
73
 
#endif
74
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
75
 
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
 
96
/* GnuTLS */
 
97
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
 
98
                                   functions:
 
99
                                   gnutls_*
 
100
                                   init_gnutls_session(),
 
101
                                   GNUTLS_* */
 
102
#include <gnutls/openpgp.h>
 
103
                          /* gnutls_certificate_set_openpgp_key_file(),
 
104
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
105
 
 
106
/* GPGME */
 
107
#include <gpgme.h>              /* All GPGME types, constants and
 
108
                                   functions:
 
109
                                   gpgme_*
 
110
                                   GPGME_PROTOCOL_OpenPGP,
 
111
                                   GPG_ERR_NO_* */
 
112
 
76
113
#define BUFFER_SIZE 256
77
 
#define DH_BITS 1024
 
114
 
 
115
#define PATHDIR "/conf/conf.d/mandos"
 
116
#define SECKEY "seckey.txt"
 
117
#define PUBKEY "pubkey.txt"
78
118
 
79
119
bool debug = false;
 
120
static const char mandos_protocol_version[] = "1";
 
121
const char *argp_program_version = "mandos-client " VERSION;
 
122
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
80
123
 
 
124
/* Used for passing in values through the Avahi callback functions */
81
125
typedef struct {
82
 
  gnutls_session_t session;
 
126
  AvahiSimplePoll *simple_poll;
 
127
  AvahiServer *server;
83
128
  gnutls_certificate_credentials_t cred;
 
129
  unsigned int dh_bits;
84
130
  gnutls_dh_params_t dh_params;
85
 
} encrypted_session;
86
 
 
87
 
 
88
 
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
89
 
                            char **new_packet, const char *homedir){
90
 
  gpgme_data_t dh_crypto, dh_plain;
 
131
  const char *priority;
91
132
  gpgme_ctx_t ctx;
 
133
} mandos_context;
 
134
 
 
135
/* global context so signal handler can reach it*/
 
136
mandos_context mc;
 
137
 
 
138
/*
 
139
 * Make additional room in "buffer" for at least BUFFER_SIZE
 
140
 * additional bytes. "buffer_capacity" is how much is currently
 
141
 * allocated, "buffer_length" is how much is already used.
 
142
 */
 
143
size_t incbuffer(char **buffer, size_t buffer_length,
 
144
                  size_t buffer_capacity){
 
145
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
 
146
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
147
    if(buffer == NULL){
 
148
      return 0;
 
149
    }
 
150
    buffer_capacity += BUFFER_SIZE;
 
151
  }
 
152
  return buffer_capacity;
 
153
}
 
154
 
 
155
/* 
 
156
 * Initialize GPGME.
 
157
 */
 
158
static bool init_gpgme(const char *seckey,
 
159
                       const char *pubkey, const char *tempdir){
 
160
  int ret;
92
161
  gpgme_error_t rc;
93
 
  ssize_t ret;
94
 
  ssize_t new_packet_capacity = 0;
95
 
  ssize_t new_packet_length = 0;
96
162
  gpgme_engine_info_t engine_info;
97
 
 
98
 
  if (debug){
99
 
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
 
163
  
 
164
  
 
165
  /*
 
166
   * Helper function to insert pub and seckey to the engine keyring.
 
167
   */
 
168
  bool import_key(const char *filename){
 
169
    int fd;
 
170
    gpgme_data_t pgp_data;
 
171
    
 
172
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
173
    if(fd == -1){
 
174
      perror("open");
 
175
      return false;
 
176
    }
 
177
    
 
178
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
179
    if(rc != GPG_ERR_NO_ERROR){
 
180
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
181
              gpgme_strsource(rc), gpgme_strerror(rc));
 
182
      return false;
 
183
    }
 
184
    
 
185
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
186
    if(rc != GPG_ERR_NO_ERROR){
 
187
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
 
188
              gpgme_strsource(rc), gpgme_strerror(rc));
 
189
      return false;
 
190
    }
 
191
    
 
192
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
193
    if(ret == -1){
 
194
      perror("close");
 
195
    }
 
196
    gpgme_data_release(pgp_data);
 
197
    return true;
 
198
  }
 
199
  
 
200
  if(debug){
 
201
    fprintf(stderr, "Initializing GPGME\n");
100
202
  }
101
203
  
102
204
  /* Init GPGME */
103
205
  gpgme_check_version(NULL);
104
 
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
206
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
207
  if(rc != GPG_ERR_NO_ERROR){
 
208
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
209
            gpgme_strsource(rc), gpgme_strerror(rc));
 
210
    return false;
 
211
  }
105
212
  
106
 
  /* Set GPGME home directory */
107
 
  rc = gpgme_get_engine_info (&engine_info);
108
 
  if (rc != GPG_ERR_NO_ERROR){
 
213
    /* Set GPGME home directory for the OpenPGP engine only */
 
214
  rc = gpgme_get_engine_info(&engine_info);
 
215
  if(rc != GPG_ERR_NO_ERROR){
109
216
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
110
217
            gpgme_strsource(rc), gpgme_strerror(rc));
111
 
    return -1;
 
218
    return false;
112
219
  }
113
220
  while(engine_info != NULL){
114
221
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
115
222
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
116
 
                            engine_info->file_name, homedir);
 
223
                            engine_info->file_name, tempdir);
117
224
      break;
118
225
    }
119
226
    engine_info = engine_info->next;
120
227
  }
121
228
  if(engine_info == NULL){
122
 
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
123
 
    return -1;
124
 
  }
125
 
  
126
 
  /* Create new GPGME data buffer from packet buffer */
127
 
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
128
 
  if (rc != GPG_ERR_NO_ERROR){
 
229
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
230
    return false;
 
231
  }
 
232
  
 
233
  /* Create new GPGME "context" */
 
234
  rc = gpgme_new(&(mc.ctx));
 
235
  if(rc != GPG_ERR_NO_ERROR){
 
236
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
237
            gpgme_strsource(rc), gpgme_strerror(rc));
 
238
    return false;
 
239
  }
 
240
  
 
241
  if(not import_key(pubkey) or not import_key(seckey)){
 
242
    return false;
 
243
  }
 
244
  
 
245
  return true; 
 
246
}
 
247
 
 
248
/* 
 
249
 * Decrypt OpenPGP data.
 
250
 * Returns -1 on error
 
251
 */
 
252
static ssize_t pgp_packet_decrypt(const char *cryptotext,
 
253
                                  size_t crypto_size,
 
254
                                  char **plaintext){
 
255
  gpgme_data_t dh_crypto, dh_plain;
 
256
  gpgme_error_t rc;
 
257
  ssize_t ret;
 
258
  size_t plaintext_capacity = 0;
 
259
  ssize_t plaintext_length = 0;
 
260
  
 
261
  if(debug){
 
262
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
263
  }
 
264
  
 
265
  /* Create new GPGME data buffer from memory cryptotext */
 
266
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
267
                               0);
 
268
  if(rc != GPG_ERR_NO_ERROR){
129
269
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
130
270
            gpgme_strsource(rc), gpgme_strerror(rc));
131
271
    return -1;
133
273
  
134
274
  /* Create new empty GPGME data buffer for the plaintext */
135
275
  rc = gpgme_data_new(&dh_plain);
136
 
  if (rc != GPG_ERR_NO_ERROR){
 
276
  if(rc != GPG_ERR_NO_ERROR){
137
277
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
138
278
            gpgme_strsource(rc), gpgme_strerror(rc));
139
 
    return -1;
140
 
  }
141
 
  
142
 
  /* Create new GPGME "context" */
143
 
  rc = gpgme_new(&ctx);
144
 
  if (rc != GPG_ERR_NO_ERROR){
145
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
146
 
            gpgme_strsource(rc), gpgme_strerror(rc));
147
 
    return -1;
148
 
  }
149
 
  
150
 
  /* Decrypt data from the FILE pointer to the plaintext data
151
 
     buffer */
152
 
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
153
 
  if (rc != GPG_ERR_NO_ERROR){
 
279
    gpgme_data_release(dh_crypto);
 
280
    return -1;
 
281
  }
 
282
  
 
283
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
284
     data buffer */
 
285
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
286
  if(rc != GPG_ERR_NO_ERROR){
154
287
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
155
288
            gpgme_strsource(rc), gpgme_strerror(rc));
156
 
    return -1;
 
289
    plaintext_length = -1;
 
290
    if(debug){
 
291
      gpgme_decrypt_result_t result;
 
292
      result = gpgme_op_decrypt_result(mc.ctx);
 
293
      if(result == NULL){
 
294
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
295
      } else {
 
296
        fprintf(stderr, "Unsupported algorithm: %s\n",
 
297
                result->unsupported_algorithm);
 
298
        fprintf(stderr, "Wrong key usage: %u\n",
 
299
                result->wrong_key_usage);
 
300
        if(result->file_name != NULL){
 
301
          fprintf(stderr, "File name: %s\n", result->file_name);
 
302
        }
 
303
        gpgme_recipient_t recipient;
 
304
        recipient = result->recipients;
 
305
        if(recipient){
 
306
          while(recipient != NULL){
 
307
            fprintf(stderr, "Public key algorithm: %s\n",
 
308
                    gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
309
            fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
310
            fprintf(stderr, "Secret key available: %s\n",
 
311
                    recipient->status == GPG_ERR_NO_SECKEY
 
312
                    ? "No" : "Yes");
 
313
            recipient = recipient->next;
 
314
          }
 
315
        }
 
316
      }
 
317
    }
 
318
    goto decrypt_end;
157
319
  }
158
 
 
 
320
  
159
321
  if(debug){
160
 
    fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
161
 
  }
162
 
 
163
 
  if (debug){
164
 
    gpgme_decrypt_result_t result;
165
 
    result = gpgme_op_decrypt_result(ctx);
166
 
    if (result == NULL){
167
 
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
168
 
    } else {
169
 
      fprintf(stderr, "Unsupported algorithm: %s\n",
170
 
              result->unsupported_algorithm);
171
 
      fprintf(stderr, "Wrong key usage: %d\n",
172
 
              result->wrong_key_usage);
173
 
      if(result->file_name != NULL){
174
 
        fprintf(stderr, "File name: %s\n", result->file_name);
175
 
      }
176
 
      gpgme_recipient_t recipient;
177
 
      recipient = result->recipients;
178
 
      if(recipient){
179
 
        while(recipient != NULL){
180
 
          fprintf(stderr, "Public key algorithm: %s\n",
181
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
182
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
183
 
          fprintf(stderr, "Secret key available: %s\n",
184
 
                  recipient->status == GPG_ERR_NO_SECKEY
185
 
                  ? "No" : "Yes");
186
 
          recipient = recipient->next;
187
 
        }
188
 
      }
189
 
    }
190
 
  }
191
 
  
192
 
  /* Delete the GPGME FILE pointer cryptotext data buffer */
193
 
  gpgme_data_release(dh_crypto);
 
322
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
323
  }
194
324
  
195
325
  /* Seek back to the beginning of the GPGME plaintext data buffer */
196
 
  gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
197
 
 
198
 
  *new_packet = 0;
 
326
  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
 
327
    perror("gpgme_data_seek");
 
328
    plaintext_length = -1;
 
329
    goto decrypt_end;
 
330
  }
 
331
  
 
332
  *plaintext = NULL;
199
333
  while(true){
200
 
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
201
 
      *new_packet = realloc(*new_packet,
202
 
                            (unsigned int)new_packet_capacity
203
 
                            + BUFFER_SIZE);
204
 
      if (*new_packet == NULL){
205
 
        perror("realloc");
206
 
        return -1;
207
 
      }
208
 
      new_packet_capacity += BUFFER_SIZE;
 
334
    plaintext_capacity = incbuffer(plaintext,
 
335
                                      (size_t)plaintext_length,
 
336
                                      plaintext_capacity);
 
337
    if(plaintext_capacity == 0){
 
338
        perror("incbuffer");
 
339
        plaintext_length = -1;
 
340
        goto decrypt_end;
209
341
    }
210
342
    
211
 
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
 
343
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
212
344
                          BUFFER_SIZE);
213
345
    /* Print the data, if any */
214
 
    if (ret == 0){
 
346
    if(ret == 0){
 
347
      /* EOF */
215
348
      break;
216
349
    }
217
350
    if(ret < 0){
218
351
      perror("gpgme_data_read");
219
 
      return -1;
220
 
    }
221
 
    new_packet_length += ret;
222
 
  }
223
 
 
224
 
  /* FIXME: check characters before printing to screen so to not print
225
 
     terminal control characters */
226
 
  /*   if(debug){ */
227
 
  /*     fprintf(stderr, "decrypted password is: "); */
228
 
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
229
 
  /*     fprintf(stderr, "\n"); */
230
 
  /*   } */
 
352
      plaintext_length = -1;
 
353
      goto decrypt_end;
 
354
    }
 
355
    plaintext_length += ret;
 
356
  }
 
357
  
 
358
  if(debug){
 
359
    fprintf(stderr, "Decrypted password is: ");
 
360
    for(ssize_t i = 0; i < plaintext_length; i++){
 
361
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
 
362
    }
 
363
    fprintf(stderr, "\n");
 
364
  }
 
365
  
 
366
 decrypt_end:
 
367
  
 
368
  /* Delete the GPGME cryptotext data buffer */
 
369
  gpgme_data_release(dh_crypto);
231
370
  
232
371
  /* Delete the GPGME plaintext data buffer */
233
372
  gpgme_data_release(dh_plain);
234
 
  return new_packet_length;
 
373
  return plaintext_length;
235
374
}
236
375
 
237
 
static const char * safer_gnutls_strerror (int value) {
238
 
  const char *ret = gnutls_strerror (value);
239
 
  if (ret == NULL)
 
376
static const char * safer_gnutls_strerror(int value){
 
377
  const char *ret = gnutls_strerror(value); /* Spurious warning from
 
378
                                               -Wunreachable-code */
 
379
  if(ret == NULL)
240
380
    ret = "(unknown)";
241
381
  return ret;
242
382
}
243
383
 
244
 
void debuggnutls(__attribute__((unused)) int level,
245
 
                 const char* string){
246
 
  fprintf(stderr, "%s", string);
 
384
/* GnuTLS log function callback */
 
385
static void debuggnutls(__attribute__((unused)) int level,
 
386
                        const char* string){
 
387
  fprintf(stderr, "GnuTLS: %s", string);
247
388
}
248
389
 
249
 
int initgnutls(encrypted_session *es){
250
 
  const char *err;
 
390
static int init_gnutls_global(const char *pubkeyfilename,
 
391
                              const char *seckeyfilename){
251
392
  int ret;
252
393
  
253
394
  if(debug){
254
395
    fprintf(stderr, "Initializing GnuTLS\n");
255
396
  }
256
397
  
257
 
  if ((ret = gnutls_global_init ())
258
 
      != GNUTLS_E_SUCCESS) {
259
 
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
398
  ret = gnutls_global_init();
 
399
  if(ret != GNUTLS_E_SUCCESS){
 
400
    fprintf(stderr, "GnuTLS global_init: %s\n",
 
401
            safer_gnutls_strerror(ret));
260
402
    return -1;
261
403
  }
262
 
 
263
 
  if (debug){
 
404
  
 
405
  if(debug){
 
406
    /* "Use a log level over 10 to enable all debugging options."
 
407
     * - GnuTLS manual
 
408
     */
264
409
    gnutls_global_set_log_level(11);
265
410
    gnutls_global_set_log_function(debuggnutls);
266
411
  }
267
412
  
268
 
  /* openpgp credentials */
269
 
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
270
 
      != GNUTLS_E_SUCCESS) {
271
 
    fprintf (stderr, "memory error: %s\n",
272
 
             safer_gnutls_strerror(ret));
 
413
  /* OpenPGP credentials */
 
414
  gnutls_certificate_allocate_credentials(&mc.cred);
 
415
  if(ret != GNUTLS_E_SUCCESS){
 
416
    fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
 
417
                                                    from
 
418
                                                    -Wunreachable-code
 
419
                                                 */
 
420
            safer_gnutls_strerror(ret));
 
421
    gnutls_global_deinit();
273
422
    return -1;
274
423
  }
275
424
  
276
425
  if(debug){
277
 
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
278
 
            " and keyfile %s as GnuTLS credentials\n", CERTFILE,
279
 
            KEYFILE);
 
426
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
427
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
 
428
            seckeyfilename);
280
429
  }
281
430
  
282
431
  ret = gnutls_certificate_set_openpgp_key_file
283
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
284
 
  if (ret != GNUTLS_E_SUCCESS) {
285
 
    fprintf
286
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
287
 
       " '%s')\n",
288
 
       ret, CERTFILE, KEYFILE);
289
 
    fprintf(stdout, "The Error is: %s\n",
290
 
            safer_gnutls_strerror(ret));
291
 
    return -1;
292
 
  }
293
 
  
294
 
  //GnuTLS server initialization
295
 
  if ((ret = gnutls_dh_params_init (&es->dh_params))
296
 
      != GNUTLS_E_SUCCESS) {
297
 
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
298
 
             safer_gnutls_strerror(ret));
299
 
    return -1;
300
 
  }
301
 
  
302
 
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
303
 
      != GNUTLS_E_SUCCESS) {
304
 
    fprintf (stderr, "Error in prime generation: %s\n",
305
 
             safer_gnutls_strerror(ret));
306
 
    return -1;
307
 
  }
308
 
  
309
 
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
310
 
  
311
 
  // GnuTLS session creation
312
 
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
313
 
      != GNUTLS_E_SUCCESS){
 
432
    (mc.cred, pubkeyfilename, seckeyfilename,
 
433
     GNUTLS_OPENPGP_FMT_BASE64);
 
434
  if(ret != GNUTLS_E_SUCCESS){
 
435
    fprintf(stderr,
 
436
            "Error[%d] while reading the OpenPGP key pair ('%s',"
 
437
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
438
    fprintf(stderr, "The GnuTLS error is: %s\n",
 
439
            safer_gnutls_strerror(ret));
 
440
    goto globalfail;
 
441
  }
 
442
  
 
443
  /* GnuTLS server initialization */
 
444
  ret = gnutls_dh_params_init(&mc.dh_params);
 
445
  if(ret != GNUTLS_E_SUCCESS){
 
446
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
 
447
            " %s\n", safer_gnutls_strerror(ret));
 
448
    goto globalfail;
 
449
  }
 
450
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
451
  if(ret != GNUTLS_E_SUCCESS){
 
452
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
 
453
            safer_gnutls_strerror(ret));
 
454
    goto globalfail;
 
455
  }
 
456
  
 
457
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
458
  
 
459
  return 0;
 
460
  
 
461
 globalfail:
 
462
  
 
463
  gnutls_certificate_free_credentials(mc.cred);
 
464
  gnutls_global_deinit();
 
465
  gnutls_dh_params_deinit(mc.dh_params);
 
466
  return -1;
 
467
}
 
468
 
 
469
static int init_gnutls_session(gnutls_session_t *session){
 
470
  int ret;
 
471
  /* GnuTLS session creation */
 
472
  ret = gnutls_init(session, GNUTLS_SERVER);
 
473
  if(ret != GNUTLS_E_SUCCESS){
314
474
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
315
475
            safer_gnutls_strerror(ret));
316
476
  }
317
477
  
318
 
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
319
 
      != GNUTLS_E_SUCCESS) {
320
 
    fprintf(stderr, "Syntax error at: %s\n", err);
321
 
    fprintf(stderr, "GnuTLS error: %s\n",
322
 
            safer_gnutls_strerror(ret));
323
 
    return -1;
 
478
  {
 
479
    const char *err;
 
480
    ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
481
    if(ret != GNUTLS_E_SUCCESS){
 
482
      fprintf(stderr, "Syntax error at: %s\n", err);
 
483
      fprintf(stderr, "GnuTLS error: %s\n",
 
484
              safer_gnutls_strerror(ret));
 
485
      gnutls_deinit(*session);
 
486
      return -1;
 
487
    }
324
488
  }
325
489
  
326
 
  if ((ret = gnutls_credentials_set
327
 
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
328
 
      != GNUTLS_E_SUCCESS) {
329
 
    fprintf(stderr, "Error setting a credentials set: %s\n",
 
490
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
491
                               mc.cred);
 
492
  if(ret != GNUTLS_E_SUCCESS){
 
493
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
330
494
            safer_gnutls_strerror(ret));
 
495
    gnutls_deinit(*session);
331
496
    return -1;
332
497
  }
333
498
  
334
499
  /* ignore client certificate if any. */
335
 
  gnutls_certificate_server_set_request (es->session,
336
 
                                         GNUTLS_CERT_IGNORE);
 
500
  gnutls_certificate_server_set_request(*session,
 
501
                                        GNUTLS_CERT_IGNORE);
337
502
  
338
 
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
 
503
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
339
504
  
340
505
  return 0;
341
506
}
342
507
 
343
 
void empty_log(__attribute__((unused)) AvahiLogLevel level,
344
 
               __attribute__((unused)) const char *txt){}
 
508
/* Avahi log function callback */
 
509
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
510
                      __attribute__((unused)) const char *txt){}
345
511
 
346
 
int start_mandos_communication(const char *ip, uint16_t port,
347
 
                               unsigned int if_index){
 
512
/* Called when a Mandos server is found */
 
513
static int start_mandos_communication(const char *ip, uint16_t port,
 
514
                                      AvahiIfIndex if_index,
 
515
                                      int af){
348
516
  int ret, tcp_sd;
349
 
  struct sockaddr_in6 to;
350
 
  encrypted_session es;
 
517
  ssize_t sret;
 
518
  union {
 
519
    struct sockaddr_in in;
 
520
    struct sockaddr_in6 in6;
 
521
  } to;
351
522
  char *buffer = NULL;
352
523
  char *decrypted_buffer;
353
524
  size_t buffer_length = 0;
354
525
  size_t buffer_capacity = 0;
355
526
  ssize_t decrypted_buffer_size;
356
 
  size_t written = 0;
 
527
  size_t written;
357
528
  int retval = 0;
358
 
  char interface[IF_NAMESIZE];
 
529
  gnutls_session_t session;
 
530
  int pf;                       /* Protocol family */
 
531
  
 
532
  switch(af){
 
533
  case AF_INET6:
 
534
    pf = PF_INET6;
 
535
    break;
 
536
  case AF_INET:
 
537
    pf = PF_INET;
 
538
    break;
 
539
  default:
 
540
    fprintf(stderr, "Bad address family: %d\n", af);
 
541
    return -1;
 
542
  }
 
543
  
 
544
  ret = init_gnutls_session(&session);
 
545
  if(ret != 0){
 
546
    return -1;
 
547
  }
359
548
  
360
549
  if(debug){
361
 
    fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
 
550
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
 
551
            "\n", ip, port);
362
552
  }
363
553
  
364
 
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
365
 
  if(tcp_sd < 0) {
 
554
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
555
  if(tcp_sd < 0){
366
556
    perror("socket");
367
557
    return -1;
368
558
  }
369
559
  
370
 
  if(if_indextoname(if_index, interface) == NULL){
371
 
    if(debug){
372
 
      perror("if_indextoname");
373
 
    }
374
 
    return -1;
375
 
  }
376
 
  
377
 
  if(debug){
378
 
    fprintf(stderr, "Binding to interface %s\n", interface);
379
 
  }
380
 
  
381
 
  memset(&to,0,sizeof(to));     /* Spurious warning */
382
 
  to.sin6_family = AF_INET6;
383
 
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
384
 
  if (ret < 0 ){
 
560
  memset(&to, 0, sizeof(to));
 
561
  if(af == AF_INET6){
 
562
    to.in6.sin6_family = (uint16_t)af;
 
563
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
564
  } else {                      /* IPv4 */
 
565
    to.in.sin_family = (sa_family_t)af;
 
566
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
567
  }
 
568
  if(ret < 0 ){
385
569
    perror("inet_pton");
386
570
    return -1;
387
 
  }  
 
571
  }
388
572
  if(ret == 0){
389
573
    fprintf(stderr, "Bad address: %s\n", ip);
390
574
    return -1;
391
575
  }
392
 
  to.sin6_port = htons(port);   /* Spurious warning */
393
 
  
394
 
  to.sin6_scope_id = (uint32_t)if_index;
 
576
  if(af == AF_INET6){
 
577
    to.in6.sin6_port = htons(port); /* Spurious warnings from
 
578
                                       -Wconversion and
 
579
                                       -Wunreachable-code */
 
580
    
 
581
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
 
582
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
 
583
                              -Wunreachable-code*/
 
584
      if(if_index == AVAHI_IF_UNSPEC){
 
585
        fprintf(stderr, "An IPv6 link-local address is incomplete"
 
586
                " without a network interface\n");
 
587
        return -1;
 
588
      }
 
589
      /* Set the network interface number as scope */
 
590
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
591
    }
 
592
  } else {
 
593
    to.in.sin_port = htons(port); /* Spurious warnings from
 
594
                                     -Wconversion and
 
595
                                     -Wunreachable-code */
 
596
  }
395
597
  
396
598
  if(debug){
397
 
    fprintf(stderr, "Connection to: %s\n", ip);
 
599
    if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
 
600
      char interface[IF_NAMESIZE];
 
601
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
602
        perror("if_indextoname");
 
603
      } else {
 
604
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
 
605
                ip, interface, port);
 
606
      }
 
607
    } else {
 
608
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
 
609
              port);
 
610
    }
 
611
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
 
612
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
 
613
    const char *pcret;
 
614
    if(af == AF_INET6){
 
615
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
 
616
                        sizeof(addrstr));
 
617
    } else {
 
618
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
 
619
                        sizeof(addrstr));
 
620
    }
 
621
    if(pcret == NULL){
 
622
      perror("inet_ntop");
 
623
    } else {
 
624
      if(strcmp(addrstr, ip) != 0){
 
625
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
 
626
      }
 
627
    }
398
628
  }
399
629
  
400
 
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
401
 
  if (ret < 0){
 
630
  if(af == AF_INET6){
 
631
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
632
  } else {
 
633
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
634
  }
 
635
  if(ret < 0){
402
636
    perror("connect");
403
637
    return -1;
404
638
  }
405
639
  
406
 
  ret = initgnutls (&es);
407
 
  if (ret != 0){
408
 
    retval = -1;
409
 
    return -1;
 
640
  const char *out = mandos_protocol_version;
 
641
  written = 0;
 
642
  while(true){
 
643
    size_t out_size = strlen(out);
 
644
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
 
645
                                   out_size - written));
 
646
    if(ret == -1){
 
647
      perror("write");
 
648
      retval = -1;
 
649
      goto mandos_end;
 
650
    }
 
651
    written += (size_t)ret;
 
652
    if(written < out_size){
 
653
      continue;
 
654
    } else {
 
655
      if(out == mandos_protocol_version){
 
656
        written = 0;
 
657
        out = "\r\n";
 
658
      } else {
 
659
        break;
 
660
      }
 
661
    }
410
662
  }
411
663
  
412
 
  gnutls_transport_set_ptr (es.session,
413
 
                            (gnutls_transport_ptr_t) tcp_sd);
414
 
  
415
664
  if(debug){
416
665
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
417
666
  }
418
667
  
419
 
  ret = gnutls_handshake (es.session);
420
 
  
421
 
  if (ret != GNUTLS_E_SUCCESS){
 
668
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
669
  
 
670
  do{
 
671
    ret = gnutls_handshake(session);
 
672
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
673
  
 
674
  if(ret != GNUTLS_E_SUCCESS){
422
675
    if(debug){
423
 
      fprintf(stderr, "\n*** Handshake failed ***\n");
424
 
      gnutls_perror (ret);
 
676
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
677
      gnutls_perror(ret);
425
678
    }
426
679
    retval = -1;
427
 
    goto exit;
 
680
    goto mandos_end;
428
681
  }
429
682
  
430
 
  //Retrieve OpenPGP packet that contains the wanted password
 
683
  /* Read OpenPGP packet that contains the wanted password */
431
684
  
432
685
  if(debug){
433
 
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
 
686
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
434
687
            ip);
435
688
  }
436
 
 
 
689
  
437
690
  while(true){
438
 
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
439
 
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
440
 
      if (buffer == NULL){
441
 
        perror("realloc");
442
 
        goto exit;
443
 
      }
444
 
      buffer_capacity += BUFFER_SIZE;
 
691
    buffer_capacity = incbuffer(&buffer, buffer_length,
 
692
                                   buffer_capacity);
 
693
    if(buffer_capacity == 0){
 
694
      perror("incbuffer");
 
695
      retval = -1;
 
696
      goto mandos_end;
445
697
    }
446
698
    
447
 
    ret = gnutls_record_recv
448
 
      (es.session, buffer+buffer_length, BUFFER_SIZE);
449
 
    if (ret == 0){
 
699
    sret = gnutls_record_recv(session, buffer+buffer_length,
 
700
                              BUFFER_SIZE);
 
701
    if(sret == 0){
450
702
      break;
451
703
    }
452
 
    if (ret < 0){
453
 
      switch(ret){
 
704
    if(sret < 0){
 
705
      switch(sret){
454
706
      case GNUTLS_E_INTERRUPTED:
455
707
      case GNUTLS_E_AGAIN:
456
708
        break;
457
709
      case GNUTLS_E_REHANDSHAKE:
458
 
        ret = gnutls_handshake (es.session);
459
 
        if (ret < 0){
460
 
          fprintf(stderr, "\n*** Handshake failed ***\n");
461
 
          gnutls_perror (ret);
 
710
        do{
 
711
          ret = gnutls_handshake(session);
 
712
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
713
        if(ret < 0){
 
714
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
715
          gnutls_perror(ret);
462
716
          retval = -1;
463
 
          goto exit;
 
717
          goto mandos_end;
464
718
        }
465
719
        break;
466
720
      default:
467
721
        fprintf(stderr, "Unknown error while reading data from"
468
 
                " encrypted session with mandos server\n");
 
722
                " encrypted session with Mandos server\n");
469
723
        retval = -1;
470
 
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
471
 
        goto exit;
 
724
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
725
        goto mandos_end;
472
726
      }
473
727
    } else {
474
 
      buffer_length += (size_t) ret;
 
728
      buffer_length += (size_t) sret;
475
729
    }
476
730
  }
477
731
  
478
 
  if (buffer_length > 0){
 
732
  if(debug){
 
733
    fprintf(stderr, "Closing TLS session\n");
 
734
  }
 
735
  
 
736
  gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
737
  
 
738
  if(buffer_length > 0){
479
739
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
480
740
                                               buffer_length,
481
 
                                               &decrypted_buffer,
482
 
                                               CERT_ROOT);
483
 
    if (decrypted_buffer_size >= 0){
484
 
      while(written < decrypted_buffer_size){
485
 
        ret = (int)fwrite (decrypted_buffer + written, 1,
486
 
                           (size_t)decrypted_buffer_size - written,
487
 
                           stdout);
 
741
                                               &decrypted_buffer);
 
742
    if(decrypted_buffer_size >= 0){
 
743
      written = 0;
 
744
      while(written < (size_t) decrypted_buffer_size){
 
745
        ret = (int)fwrite(decrypted_buffer + written, 1,
 
746
                          (size_t)decrypted_buffer_size - written,
 
747
                          stdout);
488
748
        if(ret == 0 and ferror(stdout)){
489
749
          if(debug){
490
750
            fprintf(stderr, "Error writing encrypted data: %s\n",
499
759
    } else {
500
760
      retval = -1;
501
761
    }
502
 
  }
503
 
 
504
 
  //shutdown procedure
505
 
 
506
 
  if(debug){
507
 
    fprintf(stderr, "Closing TLS session\n");
508
 
  }
509
 
 
 
762
  } else {
 
763
    retval = -1;
 
764
  }
 
765
  
 
766
  /* Shutdown procedure */
 
767
  
 
768
 mandos_end:
510
769
  free(buffer);
511
 
  gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
512
 
 exit:
513
 
  close(tcp_sd);
514
 
  gnutls_deinit (es.session);
515
 
  gnutls_certificate_free_credentials (es.cred);
516
 
  gnutls_global_deinit ();
 
770
  ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
771
  if(ret == -1){
 
772
    perror("close");
 
773
  }
 
774
  gnutls_deinit(session);
517
775
  return retval;
518
776
}
519
777
 
520
 
static AvahiSimplePoll *simple_poll = NULL;
521
 
static AvahiServer *server = NULL;
522
 
 
523
 
static void resolve_callback(
524
 
    AvahiSServiceResolver *r,
525
 
    AvahiIfIndex interface,
526
 
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
527
 
    AvahiResolverEvent event,
528
 
    const char *name,
529
 
    const char *type,
530
 
    const char *domain,
531
 
    const char *host_name,
532
 
    const AvahiAddress *address,
533
 
    uint16_t port,
534
 
    AVAHI_GCC_UNUSED AvahiStringList *txt,
535
 
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
536
 
    AVAHI_GCC_UNUSED void* userdata) {
537
 
    
538
 
  assert(r);                    /* Spurious warning */
 
778
static void resolve_callback(AvahiSServiceResolver *r,
 
779
                             AvahiIfIndex interface,
 
780
                             AvahiProtocol proto,
 
781
                             AvahiResolverEvent event,
 
782
                             const char *name,
 
783
                             const char *type,
 
784
                             const char *domain,
 
785
                             const char *host_name,
 
786
                             const AvahiAddress *address,
 
787
                             uint16_t port,
 
788
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
 
789
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
790
                             flags,
 
791
                             AVAHI_GCC_UNUSED void* userdata){
 
792
  assert(r);
539
793
  
540
794
  /* Called whenever a service has been resolved successfully or
541
795
     timed out */
542
796
  
543
 
  switch (event) {
 
797
  switch(event){
544
798
  default:
545
799
  case AVAHI_RESOLVER_FAILURE:
546
 
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
547
 
            " type '%s' in domain '%s': %s\n", name, type, domain,
548
 
            avahi_strerror(avahi_server_errno(server)));
 
800
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
 
801
            " of type '%s' in domain '%s': %s\n", name, type, domain,
 
802
            avahi_strerror(avahi_server_errno(mc.server)));
549
803
    break;
550
804
    
551
805
  case AVAHI_RESOLVER_FOUND:
553
807
      char ip[AVAHI_ADDRESS_STR_MAX];
554
808
      avahi_address_snprint(ip, sizeof(ip), address);
555
809
      if(debug){
556
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
557
 
                " port %d\n", name, host_name, ip, port);
 
810
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
811
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
 
812
                ip, (intmax_t)interface, port);
558
813
      }
559
 
      int ret = start_mandos_communication(ip, port,
560
 
                                           (unsigned int) interface);
561
 
      if (ret == 0){
562
 
        exit(EXIT_SUCCESS);
 
814
      int ret = start_mandos_communication(ip, port, interface,
 
815
                                           avahi_proto_to_af(proto));
 
816
      if(ret == 0){
 
817
        avahi_simple_poll_quit(mc.simple_poll);
563
818
      }
564
819
    }
565
820
  }
566
821
  avahi_s_service_resolver_free(r);
567
822
}
568
823
 
569
 
static void browse_callback(
570
 
    AvahiSServiceBrowser *b,
571
 
    AvahiIfIndex interface,
572
 
    AvahiProtocol protocol,
573
 
    AvahiBrowserEvent event,
574
 
    const char *name,
575
 
    const char *type,
576
 
    const char *domain,
577
 
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
578
 
    void* userdata) {
579
 
    
580
 
    AvahiServer *s = userdata;
581
 
    assert(b);                  /* Spurious warning */
582
 
    
583
 
    /* Called whenever a new services becomes available on the LAN or
584
 
       is removed from the LAN */
585
 
    
586
 
    switch (event) {
587
 
    default:
588
 
    case AVAHI_BROWSER_FAILURE:
589
 
      
590
 
      fprintf(stderr, "(Browser) %s\n",
591
 
              avahi_strerror(avahi_server_errno(server)));
592
 
      avahi_simple_poll_quit(simple_poll);
593
 
      return;
594
 
      
595
 
    case AVAHI_BROWSER_NEW:
596
 
      /* We ignore the returned resolver object. In the callback
597
 
         function we free it. If the server is terminated before
598
 
         the callback function is called the server will free
599
 
         the resolver for us. */
600
 
      
601
 
      if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
602
 
                                         type, domain,
603
 
                                         AVAHI_PROTO_INET6, 0,
604
 
                                         resolve_callback, s)))
605
 
        fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
606
 
                avahi_strerror(avahi_server_errno(s)));
607
 
      break;
608
 
      
609
 
    case AVAHI_BROWSER_REMOVE:
610
 
      break;
611
 
      
612
 
    case AVAHI_BROWSER_ALL_FOR_NOW:
613
 
    case AVAHI_BROWSER_CACHE_EXHAUSTED:
614
 
      break;
615
 
    }
616
 
}
617
 
 
618
 
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
824
static void browse_callback(AvahiSServiceBrowser *b,
 
825
                            AvahiIfIndex interface,
 
826
                            AvahiProtocol protocol,
 
827
                            AvahiBrowserEvent event,
 
828
                            const char *name,
 
829
                            const char *type,
 
830
                            const char *domain,
 
831
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
832
                            flags,
 
833
                            AVAHI_GCC_UNUSED void* userdata){
 
834
  assert(b);
 
835
  
 
836
  /* Called whenever a new services becomes available on the LAN or
 
837
     is removed from the LAN */
 
838
  
 
839
  switch(event){
 
840
  default:
 
841
  case AVAHI_BROWSER_FAILURE:
 
842
    
 
843
    fprintf(stderr, "(Avahi browser) %s\n",
 
844
            avahi_strerror(avahi_server_errno(mc.server)));
 
845
    avahi_simple_poll_quit(mc.simple_poll);
 
846
    return;
 
847
    
 
848
  case AVAHI_BROWSER_NEW:
 
849
    /* We ignore the returned Avahi resolver object. In the callback
 
850
       function we free it. If the Avahi server is terminated before
 
851
       the callback function is called the Avahi server will free the
 
852
       resolver for us. */
 
853
    
 
854
    if(!(avahi_s_service_resolver_new(mc.server, interface,
 
855
                                       protocol, name, type, domain,
 
856
                                       AVAHI_PROTO_INET6, 0,
 
857
                                       resolve_callback, NULL)))
 
858
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
 
859
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
860
    break;
 
861
    
 
862
  case AVAHI_BROWSER_REMOVE:
 
863
    break;
 
864
    
 
865
  case AVAHI_BROWSER_ALL_FOR_NOW:
 
866
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
867
    if(debug){
 
868
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
869
    }
 
870
    break;
 
871
  }
 
872
}
 
873
 
 
874
static void handle_sigterm(__attribute__((unused)) int sig){
 
875
  int old_errno = errno;
 
876
  avahi_simple_poll_quit(mc.simple_poll);
 
877
  errno = old_errno;
 
878
}
 
879
 
 
880
int main(int argc, char *argv[]){
 
881
  AvahiSServiceBrowser *sb = NULL;
 
882
  int error;
 
883
  int ret;
 
884
  intmax_t tmpmax;
 
885
  int numchars;
 
886
  int exitcode = EXIT_SUCCESS;
 
887
  const char *interface = "eth0";
 
888
  struct ifreq network;
 
889
  int sd;
 
890
  uid_t uid;
 
891
  gid_t gid;
 
892
  char *connect_to = NULL;
 
893
  char tempdir[] = "/tmp/mandosXXXXXX";
 
894
  bool tempdir_created = false;
 
895
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
896
  const char *seckey = PATHDIR "/" SECKEY;
 
897
  const char *pubkey = PATHDIR "/" PUBKEY;
 
898
  
 
899
  /* Initialize Mandos context */
 
900
  mc = (mandos_context){ .simple_poll = NULL, .server = NULL,
 
901
                         .dh_bits = 1024, .priority = "SECURE256"
 
902
                         ":!CTYPE-X.509:+CTYPE-OPENPGP" };
 
903
  bool gnutls_initialized = false;
 
904
  bool gpgme_initialized = false;
 
905
  double delay = 2.5;
 
906
 
 
907
  struct sigaction old_sigterm_action;
 
908
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
 
909
  
 
910
  {
 
911
    struct argp_option options[] = {
 
912
      { .name = "debug", .key = 128,
 
913
        .doc = "Debug mode", .group = 3 },
 
914
      { .name = "connect", .key = 'c',
 
915
        .arg = "ADDRESS:PORT",
 
916
        .doc = "Connect directly to a specific Mandos server",
 
917
        .group = 1 },
 
918
      { .name = "interface", .key = 'i',
 
919
        .arg = "NAME",
 
920
        .doc = "Network interface that will be used to search for"
 
921
        " Mandos servers",
 
922
        .group = 1 },
 
923
      { .name = "seckey", .key = 's',
 
924
        .arg = "FILE",
 
925
        .doc = "OpenPGP secret key file base name",
 
926
        .group = 1 },
 
927
      { .name = "pubkey", .key = 'p',
 
928
        .arg = "FILE",
 
929
        .doc = "OpenPGP public key file base name",
 
930
        .group = 2 },
 
931
      { .name = "dh-bits", .key = 129,
 
932
        .arg = "BITS",
 
933
        .doc = "Bit length of the prime number used in the"
 
934
        " Diffie-Hellman key exchange",
 
935
        .group = 2 },
 
936
      { .name = "priority", .key = 130,
 
937
        .arg = "STRING",
 
938
        .doc = "GnuTLS priority string for the TLS handshake",
 
939
        .group = 1 },
 
940
      { .name = "delay", .key = 131,
 
941
        .arg = "SECONDS",
 
942
        .doc = "Maximum delay to wait for interface startup",
 
943
        .group = 2 },
 
944
      { .name = NULL }
 
945
    };
 
946
    
 
947
    error_t parse_opt(int key, char *arg,
 
948
                      struct argp_state *state){
 
949
      switch(key){
 
950
      case 128:                 /* --debug */
 
951
        debug = true;
 
952
        break;
 
953
      case 'c':                 /* --connect */
 
954
        connect_to = arg;
 
955
        break;
 
956
      case 'i':                 /* --interface */
 
957
        interface = arg;
 
958
        break;
 
959
      case 's':                 /* --seckey */
 
960
        seckey = arg;
 
961
        break;
 
962
      case 'p':                 /* --pubkey */
 
963
        pubkey = arg;
 
964
        break;
 
965
      case 129:                 /* --dh-bits */
 
966
        ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
 
967
        if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
 
968
           or arg[numchars] != '\0'){
 
969
          fprintf(stderr, "Bad number of DH bits\n");
 
970
          exit(EXIT_FAILURE);
 
971
        }
 
972
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
 
973
        break;
 
974
      case 130:                 /* --priority */
 
975
        mc.priority = arg;
 
976
        break;
 
977
      case 131:                 /* --delay */
 
978
        ret = sscanf(arg, "%lf%n", &delay, &numchars);
 
979
        if(ret < 1 or arg[numchars] != '\0'){
 
980
          fprintf(stderr, "Bad delay\n");
 
981
          exit(EXIT_FAILURE);
 
982
        }
 
983
        break;
 
984
      case ARGP_KEY_ARG:
 
985
        argp_usage(state);
 
986
      case ARGP_KEY_END:
 
987
        break;
 
988
      default:
 
989
        return ARGP_ERR_UNKNOWN;
 
990
      }
 
991
      return 0;
 
992
    }
 
993
    
 
994
    struct argp argp = { .options = options, .parser = parse_opt,
 
995
                         .args_doc = "",
 
996
                         .doc = "Mandos client -- Get and decrypt"
 
997
                         " passwords from a Mandos server" };
 
998
    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
 
999
    if(ret == ARGP_ERR_UNKNOWN){
 
1000
      fprintf(stderr, "Unknown error while parsing arguments\n");
 
1001
      exitcode = EXIT_FAILURE;
 
1002
      goto end;
 
1003
    }
 
1004
  }
 
1005
  
 
1006
  /* If the interface is down, bring it up */
 
1007
  if(interface[0] != '\0'){
 
1008
#ifdef __linux__
 
1009
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1010
       messages to mess up the prompt */
 
1011
    ret = klogctl(8, NULL, 5);
 
1012
    bool restore_loglevel = true;
 
1013
    if(ret == -1){
 
1014
      restore_loglevel = false;
 
1015
      perror("klogctl");
 
1016
    }
 
1017
#endif
 
1018
    
 
1019
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1020
    if(sd < 0){
 
1021
      perror("socket");
 
1022
      exitcode = EXIT_FAILURE;
 
1023
#ifdef __linux__
 
1024
      if(restore_loglevel){
 
1025
        ret = klogctl(7, NULL, 0);
 
1026
        if(ret == -1){
 
1027
          perror("klogctl");
 
1028
        }
 
1029
      }
 
1030
#endif
 
1031
      goto end;
 
1032
    }
 
1033
    strcpy(network.ifr_name, interface);
 
1034
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1035
    if(ret == -1){
 
1036
      perror("ioctl SIOCGIFFLAGS");
 
1037
#ifdef __linux__
 
1038
      if(restore_loglevel){
 
1039
        ret = klogctl(7, NULL, 0);
 
1040
        if(ret == -1){
 
1041
          perror("klogctl");
 
1042
        }
 
1043
      }
 
1044
#endif
 
1045
      exitcode = EXIT_FAILURE;
 
1046
      goto end;
 
1047
    }
 
1048
    if((network.ifr_flags & IFF_UP) == 0){
 
1049
      network.ifr_flags |= IFF_UP;
 
1050
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1051
      if(ret == -1){
 
1052
        perror("ioctl SIOCSIFFLAGS");
 
1053
        exitcode = EXIT_FAILURE;
 
1054
#ifdef __linux__
 
1055
        if(restore_loglevel){
 
1056
          ret = klogctl(7, NULL, 0);
 
1057
          if(ret == -1){
 
1058
            perror("klogctl");
 
1059
          }
 
1060
        }
 
1061
#endif
 
1062
        goto end;
 
1063
      }
 
1064
    }
 
1065
    /* sleep checking until interface is running */
 
1066
    for(int i=0; i < delay * 4; i++){
 
1067
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1068
      if(ret == -1){
 
1069
        perror("ioctl SIOCGIFFLAGS");
 
1070
      } else if(network.ifr_flags & IFF_RUNNING){
 
1071
        break;
 
1072
      }
 
1073
      struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1074
      ret = nanosleep(&sleeptime, NULL);
 
1075
      if(ret == -1 and errno != EINTR){
 
1076
        perror("nanosleep");
 
1077
      }
 
1078
    }
 
1079
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1080
    if(ret == -1){
 
1081
      perror("close");
 
1082
    }
 
1083
#ifdef __linux__
 
1084
    if(restore_loglevel){
 
1085
      /* Restores kernel loglevel to default */
 
1086
      ret = klogctl(7, NULL, 0);
 
1087
      if(ret == -1){
 
1088
        perror("klogctl");
 
1089
      }
 
1090
    }
 
1091
#endif
 
1092
  }
 
1093
  
 
1094
  uid = getuid();
 
1095
  gid = getgid();
 
1096
  
 
1097
  errno = 0;
 
1098
  setgid(gid);
 
1099
  if(ret == -1){
 
1100
    perror("setgid");
 
1101
  }
 
1102
  
 
1103
  ret = setuid(uid);
 
1104
  if(ret == -1){
 
1105
    perror("setuid");
 
1106
  }
 
1107
  
 
1108
  ret = init_gnutls_global(pubkey, seckey);
 
1109
  if(ret == -1){
 
1110
    fprintf(stderr, "init_gnutls_global failed\n");
 
1111
    exitcode = EXIT_FAILURE;
 
1112
    goto end;
 
1113
  } else {
 
1114
    gnutls_initialized = true;
 
1115
  }
 
1116
  
 
1117
  if(mkdtemp(tempdir) == NULL){
 
1118
    perror("mkdtemp");
 
1119
    goto end;
 
1120
  }
 
1121
  tempdir_created = true;
 
1122
  
 
1123
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
1124
    fprintf(stderr, "init_gpgme failed\n");
 
1125
    exitcode = EXIT_FAILURE;
 
1126
    goto end;
 
1127
  } else {
 
1128
    gpgme_initialized = true;
 
1129
  }
 
1130
  
 
1131
  if(interface[0] != '\0'){
 
1132
    if_index = (AvahiIfIndex) if_nametoindex(interface);
 
1133
    if(if_index == 0){
 
1134
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
1135
      exitcode = EXIT_FAILURE;
 
1136
      goto end;
 
1137
    }
 
1138
  }
 
1139
  
 
1140
  if(connect_to != NULL){
 
1141
    /* Connect directly, do not use Zeroconf */
 
1142
    /* (Mainly meant for debugging) */
 
1143
    char *address = strrchr(connect_to, ':');
 
1144
    if(address == NULL){
 
1145
      fprintf(stderr, "No colon in address\n");
 
1146
      exitcode = EXIT_FAILURE;
 
1147
      goto end;
 
1148
    }
 
1149
    uint16_t port;
 
1150
    ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
 
1151
    if(ret < 1 or tmpmax != (uint16_t)tmpmax
 
1152
       or address[numchars+1] != '\0'){
 
1153
      fprintf(stderr, "Bad port number\n");
 
1154
      exitcode = EXIT_FAILURE;
 
1155
      goto end;
 
1156
    }
 
1157
    port = (uint16_t)tmpmax;
 
1158
    *address = '\0';
 
1159
    address = connect_to;
 
1160
    /* Colon in address indicates IPv6 */
 
1161
    int af;
 
1162
    if(strchr(address, ':') != NULL){
 
1163
      af = AF_INET6;
 
1164
    } else {
 
1165
      af = AF_INET;
 
1166
    }
 
1167
    ret = start_mandos_communication(address, port, if_index, af);
 
1168
    if(ret < 0){
 
1169
      exitcode = EXIT_FAILURE;
 
1170
    } else {
 
1171
      exitcode = EXIT_SUCCESS;
 
1172
    }
 
1173
    goto end;
 
1174
  }
 
1175
  
 
1176
  if(not debug){
 
1177
    avahi_set_log_function(empty_log);
 
1178
  }
 
1179
  
 
1180
  /* Initialize the pseudo-RNG for Avahi */
 
1181
  srand((unsigned int) time(NULL));
 
1182
  
 
1183
  /* Allocate main Avahi loop object */
 
1184
  mc.simple_poll = avahi_simple_poll_new();
 
1185
  if(mc.simple_poll == NULL){
 
1186
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
1187
    exitcode = EXIT_FAILURE;
 
1188
    goto end;
 
1189
  }
 
1190
  
 
1191
  {
619
1192
    AvahiServerConfig config;
620
 
    AvahiSServiceBrowser *sb = NULL;
621
 
    int error;
622
 
    int ret;
623
 
    int returncode = EXIT_SUCCESS;
624
 
    const char *interface = "eth0";
625
 
    
626
 
    while (true){
627
 
      static struct option long_options[] = {
628
 
        {"debug", no_argument, (int *)&debug, 1},
629
 
        {"interface", required_argument, 0, 'i'},
630
 
        {0, 0, 0, 0} };
631
 
      
632
 
      int option_index = 0;
633
 
      ret = getopt_long (argc, argv, "i:", long_options,
634
 
                         &option_index);
635
 
      
636
 
      if (ret == -1){
637
 
        break;
638
 
      }
639
 
      
640
 
      switch(ret){
641
 
      case 0:
642
 
        break;
643
 
      case 'i':
644
 
        interface = optarg;
645
 
        break;
646
 
      default:
647
 
        exit(EXIT_FAILURE);
648
 
      }
649
 
    }
650
 
    
651
 
    if (not debug){
652
 
      avahi_set_log_function(empty_log);
653
 
    }
654
 
    
655
 
    /* Initialize the psuedo-RNG */
656
 
    srand((unsigned int) time(NULL));
657
 
 
658
 
    /* Allocate main loop object */
659
 
    if (!(simple_poll = avahi_simple_poll_new())) {
660
 
        fprintf(stderr, "Failed to create simple poll object.\n");
661
 
        
662
 
        goto exit;
663
 
    }
664
 
 
665
 
    /* Do not publish any local records */
 
1193
    /* Do not publish any local Zeroconf records */
666
1194
    avahi_server_config_init(&config);
667
1195
    config.publish_hinfo = 0;
668
1196
    config.publish_addresses = 0;
669
1197
    config.publish_workstation = 0;
670
1198
    config.publish_domain = 0;
671
 
 
 
1199
    
672
1200
    /* Allocate a new server */
673
 
    server = avahi_server_new(avahi_simple_poll_get(simple_poll),
674
 
                              &config, NULL, NULL, &error);
675
 
 
676
 
    /* Free the configuration data */
 
1201
    mc.server = avahi_server_new(avahi_simple_poll_get
 
1202
                                 (mc.simple_poll), &config, NULL,
 
1203
                                 NULL, &error);
 
1204
    
 
1205
    /* Free the Avahi configuration data */
677
1206
    avahi_server_config_free(&config);
678
 
 
679
 
    /* Check if creating the server object succeeded */
680
 
    if (!server) {
681
 
        fprintf(stderr, "Failed to create server: %s\n",
682
 
                avahi_strerror(error));
683
 
        returncode = EXIT_FAILURE;
684
 
        goto exit;
685
 
    }
686
 
    
687
 
    /* Create the service browser */
688
 
    sb = avahi_s_service_browser_new(server,
689
 
                                     (AvahiIfIndex)
690
 
                                     if_nametoindex(interface),
691
 
                                     AVAHI_PROTO_INET6,
692
 
                                     "_mandos._tcp", NULL, 0,
693
 
                                     browse_callback, server);
694
 
    if (!sb) {
695
 
        fprintf(stderr, "Failed to create service browser: %s\n",
696
 
                avahi_strerror(avahi_server_errno(server)));
697
 
        returncode = EXIT_FAILURE;
698
 
        goto exit;
699
 
    }
700
 
    
701
 
    /* Run the main loop */
702
 
 
703
 
    if (debug){
704
 
      fprintf(stderr, "Starting avahi loop search\n");
705
 
    }
706
 
    
707
 
    avahi_simple_poll_loop(simple_poll);
708
 
    
709
 
 exit:
710
 
 
711
 
    if (debug){
712
 
      fprintf(stderr, "%s exiting\n", argv[0]);
713
 
    }
714
 
    
715
 
    /* Cleanup things */
716
 
    if (sb)
717
 
        avahi_s_service_browser_free(sb);
718
 
    
719
 
    if (server)
720
 
        avahi_server_free(server);
721
 
 
722
 
    if (simple_poll)
723
 
        avahi_simple_poll_free(simple_poll);
724
 
 
725
 
    return returncode;
 
1207
  }
 
1208
  
 
1209
  /* Check if creating the Avahi server object succeeded */
 
1210
  if(mc.server == NULL){
 
1211
    fprintf(stderr, "Failed to create Avahi server: %s\n",
 
1212
            avahi_strerror(error));
 
1213
    exitcode = EXIT_FAILURE;
 
1214
    goto end;
 
1215
  }
 
1216
  
 
1217
  /* Create the Avahi service browser */
 
1218
  sb = avahi_s_service_browser_new(mc.server, if_index,
 
1219
                                   AVAHI_PROTO_INET6, "_mandos._tcp",
 
1220
                                   NULL, 0, browse_callback, NULL);
 
1221
  if(sb == NULL){
 
1222
    fprintf(stderr, "Failed to create service browser: %s\n",
 
1223
            avahi_strerror(avahi_server_errno(mc.server)));
 
1224
    exitcode = EXIT_FAILURE;
 
1225
    goto end;
 
1226
  }
 
1227
  
 
1228
  sigemptyset(&sigterm_action.sa_mask);
 
1229
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
 
1230
  if(ret == -1){
 
1231
    perror("sigaddset");
 
1232
    exitcode = EXIT_FAILURE;
 
1233
    goto end;
 
1234
  }
 
1235
  ret = sigaction(SIGTERM, &sigterm_action, &old_sigterm_action);
 
1236
  if(ret == -1){
 
1237
    perror("sigaction");
 
1238
    exitcode = EXIT_FAILURE;
 
1239
    goto end;
 
1240
  }  
 
1241
  
 
1242
  /* Run the main loop */
 
1243
  
 
1244
  if(debug){
 
1245
    fprintf(stderr, "Starting Avahi loop search\n");
 
1246
  }
 
1247
  
 
1248
  avahi_simple_poll_loop(mc.simple_poll);
 
1249
  
 
1250
 end:
 
1251
  
 
1252
  if(debug){
 
1253
    fprintf(stderr, "%s exiting\n", argv[0]);
 
1254
  }
 
1255
  
 
1256
  /* Cleanup things */
 
1257
  if(sb != NULL)
 
1258
    avahi_s_service_browser_free(sb);
 
1259
  
 
1260
  if(mc.server != NULL)
 
1261
    avahi_server_free(mc.server);
 
1262
  
 
1263
  if(mc.simple_poll != NULL)
 
1264
    avahi_simple_poll_free(mc.simple_poll);
 
1265
  
 
1266
  if(gnutls_initialized){
 
1267
    gnutls_certificate_free_credentials(mc.cred);
 
1268
    gnutls_global_deinit();
 
1269
    gnutls_dh_params_deinit(mc.dh_params);
 
1270
  }
 
1271
  
 
1272
  if(gpgme_initialized){
 
1273
    gpgme_release(mc.ctx);
 
1274
  }
 
1275
  
 
1276
  /* Removes the temp directory used by GPGME */
 
1277
  if(tempdir_created){
 
1278
    DIR *d;
 
1279
    struct dirent *direntry;
 
1280
    d = opendir(tempdir);
 
1281
    if(d == NULL){
 
1282
      if(errno != ENOENT){
 
1283
        perror("opendir");
 
1284
      }
 
1285
    } else {
 
1286
      while(true){
 
1287
        direntry = readdir(d);
 
1288
        if(direntry == NULL){
 
1289
          break;
 
1290
        }
 
1291
        /* Skip "." and ".." */
 
1292
        if(direntry->d_name[0] == '.'
 
1293
           and (direntry->d_name[1] == '\0'
 
1294
                or (direntry->d_name[1] == '.'
 
1295
                    and direntry->d_name[2] == '\0'))){
 
1296
          continue;
 
1297
        }
 
1298
        char *fullname = NULL;
 
1299
        ret = asprintf(&fullname, "%s/%s", tempdir,
 
1300
                       direntry->d_name);
 
1301
        if(ret < 0){
 
1302
          perror("asprintf");
 
1303
          continue;
 
1304
        }
 
1305
        ret = remove(fullname);
 
1306
        if(ret == -1){
 
1307
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
 
1308
                  strerror(errno));
 
1309
        }
 
1310
        free(fullname);
 
1311
      }
 
1312
      closedir(d);
 
1313
    }
 
1314
    ret = rmdir(tempdir);
 
1315
    if(ret == -1 and errno != ENOENT){
 
1316
      perror("rmdir");
 
1317
    }
 
1318
  }
 
1319
  
 
1320
  return exitcode;
726
1321
}