/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-03 01:09:36 UTC
  • mfrom: (24.1.9 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20080803010936-ujme8tgxceszfbi1
* plugbasedclient.c (main): New "--userid" and "--groupid" options.
                            Take an additional non-option argument and
                            parse it as a plus-separated and -prefixed
                            list of additional options.

* plugins.d/mandosclient.c (DH_BITS): Replaced with
                                      "mandos_context.dh_bits".  All
                                      users changed.
  (certdir): Renamed to "keydir".  All users changed.
  (certfile): Renamed to "pubkeyfile".  All users changed.
  (certkey): Renamed to "seckeyfile".  All users changed.
  (encrypted_session): Replaced with "mandos_context".  All users
                       changed.
  (initgnutls): Take additional "session" and "dh_params" arguments.
                All callers changed.
  (start_mandos_communication): Take additional "mc" argument.  All
                                callers changed.  Print target IPv6
                                address if different than supplied
                                string.
  (simple_poll) Replaced with "mandos_context.simple_poll".  All users
                changed.
  (server): Replaced with "mandos_context.server".  All users changed.
  (main): Default interface to "eth0".  Rename "--certdir" to
          "--keydir", "--certkey" to "--seckey", and "--certfile" to
          "--pubkey".  New options "--dh-bits" and "--priority".  If
          the interface is not up, bring it up.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
32
32
#define _LARGEFILE_SOURCE
33
33
#define _FILE_OFFSET_BITS 64
34
34
 
35
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
36
 
 
37
 
#include <stdio.h>              /* fprintf(), stderr, fwrite(), stdout,
38
 
                                   ferror() */
39
 
#include <stdint.h>             /* uint16_t, uint32_t */
40
 
#include <stddef.h>             /* NULL, size_t, ssize_t */
41
 
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
42
 
                                   srand() */
43
 
#include <stdbool.h>            /* bool, true */
44
 
#include <string.h>             /* memset(), strcmp(), strlen(),
45
 
                                   strerror(), memcpy(), strcpy() */
46
 
#include <sys/ioctl.h>          /* ioctl */
47
 
#include <net/if.h>             /* ifreq, SIOCGIFFLAGS, SIOCSIFFLAGS,
48
 
                                   IFF_UP */
49
 
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
50
 
                                   sockaddr_in6, PF_INET6,
51
 
                                   SOCK_STREAM, INET6_ADDRSTRLEN,
52
 
                                   uid_t, gid_t */
53
 
#include <inttypes.h>           /* PRIu16 */
54
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
55
 
                                   struct in6_addr, inet_pton(),
56
 
                                   connect() */
57
 
#include <assert.h>             /* assert() */
58
 
#include <errno.h>              /* perror(), errno */
59
 
#include <time.h>               /* time() */
60
 
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
61
 
                                   SIOCSIFFLAGS, if_indextoname(),
62
 
                                   if_nametoindex(), IF_NAMESIZE */
63
 
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
64
 
                                   getuid(), getgid(), setuid(),
65
 
                                   setgid() */
66
 
#include <netinet/in.h>
67
 
#include <arpa/inet.h>          /* inet_pton(), htons */
68
 
#include <iso646.h>             /* not, and */
69
 
#include <argp.h>               /* struct argp_option, error_t, struct
70
 
                                   argp_state, struct argp,
71
 
                                   argp_parse(), ARGP_KEY_ARG,
72
 
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
73
 
 
74
 
/* Avahi */
75
 
/* All Avahi types, constants and functions
76
 
 Avahi*, avahi_*,
77
 
 AVAHI_* */
 
35
#include <stdio.h>
 
36
#include <assert.h>
 
37
#include <stdlib.h>
 
38
#include <time.h>
 
39
#include <net/if.h>             /* if_nametoindex */
 
40
#include <sys/ioctl.h>          // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
 
41
#include <net/if.h>             // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
 
42
 
78
43
#include <avahi-core/core.h>
79
44
#include <avahi-core/lookup.h>
80
45
#include <avahi-core/log.h>
82
47
#include <avahi-common/malloc.h>
83
48
#include <avahi-common/error.h>
84
49
 
85
 
/* GnuTLS */
86
 
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and functions
87
 
                                   gnutls_*
88
 
                                   init_gnutls_session(),
89
 
                                   GNUTLS_* */
90
 
#include <gnutls/openpgp.h>     /* gnutls_certificate_set_openpgp_key_file(),
91
 
                                   GNUTLS_OPENPGP_FMT_BASE64 */
92
 
 
93
 
/* GPGME */
94
 
#include <gpgme.h>              /* All GPGME types, constants and functions
95
 
                                   gpgme_*
96
 
                                   GPGME_PROTOCOL_OpenPGP,
97
 
                                   GPG_ERR_NO_* */
 
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>
98
70
 
99
71
#define BUFFER_SIZE 256
100
72
 
 
73
static const char *keydir = "/conf/conf.d/mandos";
 
74
static const char *pubkeyfile = "pubkey.txt";
 
75
static const char *seckeyfile = "seckey.txt";
 
76
 
101
77
bool debug = false;
102
 
static const char *keydir = "/conf/conf.d/mandos";
103
 
static const char mandos_protocol_version[] = "1";
104
 
const char *argp_program_version = "password-request 1.0";
105
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
106
78
 
107
 
/* Used for passing in values through the Avahi callback functions */
 
79
/* Used for passing in values through all the callback functions */
108
80
typedef struct {
109
81
  AvahiSimplePoll *simple_poll;
110
82
  AvahiServer *server;
111
83
  gnutls_certificate_credentials_t cred;
112
84
  unsigned int dh_bits;
113
 
  gnutls_dh_params_t dh_params;
114
85
  const char *priority;
115
86
} mandos_context;
116
87
 
117
 
/*
118
 
 * Make room in "buffer" for at least BUFFER_SIZE additional bytes.
119
 
 * "buffer_capacity" is how much is currently allocated,
120
 
 * "buffer_length" is how much is already used.
121
 
 */
122
 
size_t adjustbuffer(char **buffer, size_t buffer_length,
123
 
                  size_t buffer_capacity){
124
 
  if (buffer_length + BUFFER_SIZE > buffer_capacity){
125
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
126
 
    if (buffer == NULL){
127
 
      return 0;
128
 
    }
129
 
    buffer_capacity += BUFFER_SIZE;
130
 
  }
131
 
  return buffer_capacity;
132
 
}
133
 
 
134
 
/* 
135
 
 * Decrypt OpenPGP data using keyrings in HOMEDIR.
136
 
 * Returns -1 on error
137
 
 */
138
 
static ssize_t pgp_packet_decrypt (const char *cryptotext,
139
 
                                   size_t crypto_size,
140
 
                                   char **plaintext,
 
88
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
 
89
                                   char **new_packet,
141
90
                                   const char *homedir){
142
91
  gpgme_data_t dh_crypto, dh_plain;
143
92
  gpgme_ctx_t ctx;
144
93
  gpgme_error_t rc;
145
94
  ssize_t ret;
146
 
  size_t plaintext_capacity = 0;
147
 
  ssize_t plaintext_length = 0;
 
95
  ssize_t new_packet_capacity = 0;
 
96
  ssize_t new_packet_length = 0;
148
97
  gpgme_engine_info_t engine_info;
149
 
  
 
98
 
150
99
  if (debug){
151
 
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
100
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
152
101
  }
153
102
  
154
103
  /* Init GPGME */
160
109
    return -1;
161
110
  }
162
111
  
163
 
  /* Set GPGME home directory for the OpenPGP engine only */
 
112
  /* Set GPGME home directory */
164
113
  rc = gpgme_get_engine_info (&engine_info);
165
114
  if (rc != GPG_ERR_NO_ERROR){
166
115
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
176
125
    engine_info = engine_info->next;
177
126
  }
178
127
  if(engine_info == NULL){
179
 
    fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
 
128
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
180
129
    return -1;
181
130
  }
182
131
  
183
 
  /* Create new GPGME data buffer from memory cryptotext */
184
 
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
185
 
                               0);
 
132
  /* Create new GPGME data buffer from packet buffer */
 
133
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
186
134
  if (rc != GPG_ERR_NO_ERROR){
187
135
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
188
136
            gpgme_strsource(rc), gpgme_strerror(rc));
194
142
  if (rc != GPG_ERR_NO_ERROR){
195
143
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
196
144
            gpgme_strsource(rc), gpgme_strerror(rc));
197
 
    gpgme_data_release(dh_crypto);
198
145
    return -1;
199
146
  }
200
147
  
203
150
  if (rc != GPG_ERR_NO_ERROR){
204
151
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
205
152
            gpgme_strsource(rc), gpgme_strerror(rc));
206
 
    plaintext_length = -1;
207
 
    goto decrypt_end;
 
153
    return -1;
208
154
  }
209
155
  
210
 
  /* Decrypt data from the cryptotext data buffer to the plaintext
211
 
     data buffer */
 
156
  /* Decrypt data from the FILE pointer to the plaintext data
 
157
     buffer */
212
158
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
213
159
  if (rc != GPG_ERR_NO_ERROR){
214
160
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
215
161
            gpgme_strsource(rc), gpgme_strerror(rc));
216
 
    plaintext_length = -1;
217
 
    goto decrypt_end;
 
162
    return -1;
218
163
  }
219
 
  
 
164
 
220
165
  if(debug){
221
 
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
166
    fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
222
167
  }
223
 
  
 
168
 
224
169
  if (debug){
225
170
    gpgme_decrypt_result_t result;
226
171
    result = gpgme_op_decrypt_result(ctx);
229
174
    } else {
230
175
      fprintf(stderr, "Unsupported algorithm: %s\n",
231
176
              result->unsupported_algorithm);
232
 
      fprintf(stderr, "Wrong key usage: %u\n",
 
177
      fprintf(stderr, "Wrong key usage: %d\n",
233
178
              result->wrong_key_usage);
234
179
      if(result->file_name != NULL){
235
180
        fprintf(stderr, "File name: %s\n", result->file_name);
250
195
    }
251
196
  }
252
197
  
 
198
  /* Delete the GPGME FILE pointer cryptotext data buffer */
 
199
  gpgme_data_release(dh_crypto);
 
200
  
253
201
  /* Seek back to the beginning of the GPGME plaintext data buffer */
254
202
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
255
203
    perror("pgpme_data_seek");
256
 
    plaintext_length = -1;
257
 
    goto decrypt_end;
258
204
  }
259
205
  
260
 
  *plaintext = NULL;
 
206
  *new_packet = 0;
261
207
  while(true){
262
 
    plaintext_capacity = adjustbuffer(plaintext,
263
 
                                      (size_t)plaintext_length,
264
 
                                      plaintext_capacity);
265
 
    if (plaintext_capacity == 0){
266
 
        perror("adjustbuffer");
267
 
        plaintext_length = -1;
268
 
        goto decrypt_end;
 
208
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
 
209
      *new_packet = realloc(*new_packet,
 
210
                            (unsigned int)new_packet_capacity
 
211
                            + BUFFER_SIZE);
 
212
      if (*new_packet == NULL){
 
213
        perror("realloc");
 
214
        return -1;
 
215
      }
 
216
      new_packet_capacity += BUFFER_SIZE;
269
217
    }
270
218
    
271
 
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
219
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
272
220
                          BUFFER_SIZE);
273
221
    /* Print the data, if any */
274
222
    if (ret == 0){
275
 
      /* EOF */
276
223
      break;
277
224
    }
278
225
    if(ret < 0){
279
226
      perror("gpgme_data_read");
280
 
      plaintext_length = -1;
281
 
      goto decrypt_end;
 
227
      return -1;
282
228
    }
283
 
    plaintext_length += ret;
 
229
    new_packet_length += ret;
284
230
  }
285
231
 
286
 
  if(debug){
287
 
    fprintf(stderr, "Decrypted password is: ");
288
 
    for(ssize_t i = 0; i < plaintext_length; i++){
289
 
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
290
 
    }
291
 
    fprintf(stderr, "\n");
292
 
  }
293
 
  
294
 
 decrypt_end:
295
 
  
296
 
  /* Delete the GPGME cryptotext data buffer */
297
 
  gpgme_data_release(dh_crypto);
 
232
  /* FIXME: check characters before printing to screen so to not print
 
233
     terminal control characters */
 
234
  /*   if(debug){ */
 
235
  /*     fprintf(stderr, "decrypted password is: "); */
 
236
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
 
237
  /*     fprintf(stderr, "\n"); */
 
238
  /*   } */
298
239
  
299
240
  /* Delete the GPGME plaintext data buffer */
300
241
  gpgme_data_release(dh_plain);
301
 
  return plaintext_length;
 
242
  return new_packet_length;
302
243
}
303
244
 
304
245
static const char * safer_gnutls_strerror (int value) {
308
249
  return ret;
309
250
}
310
251
 
311
 
/* GnuTLS log function callback */
312
252
static void debuggnutls(__attribute__((unused)) int level,
313
253
                        const char* string){
314
 
  fprintf(stderr, "GnuTLS: %s", string);
 
254
  fprintf(stderr, "%s", string);
315
255
}
316
256
 
317
 
static int init_gnutls_global(mandos_context *mc,
318
 
                              const char *pubkeyfile,
319
 
                              const char *seckeyfile){
 
257
static int initgnutls(mandos_context *mc, gnutls_session_t *session,
 
258
                      gnutls_dh_params_t *dh_params){
 
259
  const char *err;
320
260
  int ret;
321
261
  
322
262
  if(debug){
323
263
    fprintf(stderr, "Initializing GnuTLS\n");
324
264
  }
325
 
  
326
 
  ret = gnutls_global_init();
327
 
  if (ret != GNUTLS_E_SUCCESS) {
328
 
    fprintf (stderr, "GnuTLS global_init: %s\n",
329
 
             safer_gnutls_strerror(ret));
 
265
 
 
266
  if ((ret = gnutls_global_init ())
 
267
      != GNUTLS_E_SUCCESS) {
 
268
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
330
269
    return -1;
331
270
  }
332
271
  
333
272
  if (debug){
334
 
    /* "Use a log level over 10 to enable all debugging options."
335
 
     * - GnuTLS manual
336
 
     */
337
273
    gnutls_global_set_log_level(11);
338
274
    gnutls_global_set_log_function(debuggnutls);
339
275
  }
340
276
  
341
 
  /* OpenPGP credentials */
342
 
  gnutls_certificate_allocate_credentials(&mc->cred);
343
 
  if (ret != GNUTLS_E_SUCCESS){
344
 
    fprintf (stderr, "GnuTLS memory error: %s\n",
 
277
  /* openpgp credentials */
 
278
  if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
 
279
      != GNUTLS_E_SUCCESS) {
 
280
    fprintf (stderr, "memory error: %s\n",
345
281
             safer_gnutls_strerror(ret));
346
 
    gnutls_global_deinit ();
347
282
    return -1;
348
283
  }
349
284
  
356
291
  ret = gnutls_certificate_set_openpgp_key_file
357
292
    (mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
358
293
  if (ret != GNUTLS_E_SUCCESS) {
359
 
    fprintf(stderr,
360
 
            "Error[%d] while reading the OpenPGP key pair ('%s',"
361
 
            " '%s')\n", ret, pubkeyfile, seckeyfile);
362
 
    fprintf(stdout, "The GnuTLS error is: %s\n",
 
294
    fprintf
 
295
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
 
296
       " '%s')\n",
 
297
       ret, pubkeyfile, seckeyfile);
 
298
    fprintf(stdout, "The Error is: %s\n",
363
299
            safer_gnutls_strerror(ret));
364
 
    goto globalfail;
365
 
  }
366
 
  
367
 
  /* GnuTLS server initialization */
368
 
  ret = gnutls_dh_params_init(&mc->dh_params);
369
 
  if (ret != GNUTLS_E_SUCCESS) {
370
 
    fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
371
 
             " %s\n", safer_gnutls_strerror(ret));
372
 
    goto globalfail;
373
 
  }
374
 
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
375
 
  if (ret != GNUTLS_E_SUCCESS) {
376
 
    fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
377
 
             safer_gnutls_strerror(ret));
378
 
    goto globalfail;
379
 
  }
380
 
  
381
 
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
382
 
 
383
 
  return 0;
384
 
 
385
 
 globalfail:
386
 
 
387
 
  gnutls_certificate_free_credentials(mc->cred);
388
 
  gnutls_global_deinit();
389
 
  return -1;
390
 
 
391
 
}
392
 
 
393
 
static int init_gnutls_session(mandos_context *mc,
394
 
                               gnutls_session_t *session){
395
 
  int ret;
396
 
  /* GnuTLS session creation */
397
 
  ret = gnutls_init(session, GNUTLS_SERVER);
398
 
  if (ret != GNUTLS_E_SUCCESS){
 
300
    return -1;
 
301
  }
 
302
  
 
303
  //GnuTLS server initialization
 
304
  if ((ret = gnutls_dh_params_init(dh_params))
 
305
      != GNUTLS_E_SUCCESS) {
 
306
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
 
307
             safer_gnutls_strerror(ret));
 
308
    return -1;
 
309
  }
 
310
  
 
311
  if ((ret = gnutls_dh_params_generate2(*dh_params, mc->dh_bits))
 
312
      != GNUTLS_E_SUCCESS) {
 
313
    fprintf (stderr, "Error in prime generation: %s\n",
 
314
             safer_gnutls_strerror(ret));
 
315
    return -1;
 
316
  }
 
317
  
 
318
  gnutls_certificate_set_dh_params(mc->cred, *dh_params);
 
319
  
 
320
  // GnuTLS session creation
 
321
  if ((ret = gnutls_init(session, GNUTLS_SERVER))
 
322
      != GNUTLS_E_SUCCESS){
399
323
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
400
324
            safer_gnutls_strerror(ret));
401
325
  }
402
326
  
403
 
  {
404
 
    const char *err;
405
 
    ret = gnutls_priority_set_direct(*session, mc->priority, &err);
406
 
    if (ret != GNUTLS_E_SUCCESS) {
407
 
      fprintf(stderr, "Syntax error at: %s\n", err);
408
 
      fprintf(stderr, "GnuTLS error: %s\n",
409
 
              safer_gnutls_strerror(ret));
410
 
      gnutls_deinit (*session);
411
 
      return -1;
412
 
    }
 
327
  if ((ret = gnutls_priority_set_direct(*session, mc->priority, &err))
 
328
      != GNUTLS_E_SUCCESS) {
 
329
    fprintf(stderr, "Syntax error at: %s\n", err);
 
330
    fprintf(stderr, "GnuTLS error: %s\n",
 
331
            safer_gnutls_strerror(ret));
 
332
    return -1;
413
333
  }
414
334
  
415
 
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
416
 
                               mc->cred);
417
 
  if (ret != GNUTLS_E_SUCCESS) {
418
 
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
 
335
  if ((ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
336
                                    mc->cred))
 
337
      != GNUTLS_E_SUCCESS) {
 
338
    fprintf(stderr, "Error setting a credentials set: %s\n",
419
339
            safer_gnutls_strerror(ret));
420
 
    gnutls_deinit (*session);
421
340
    return -1;
422
341
  }
423
342
  
430
349
  return 0;
431
350
}
432
351
 
433
 
/* Avahi log function callback */
434
352
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
435
353
                      __attribute__((unused)) const char *txt){}
436
354
 
437
 
/* Called when a Mandos server is found */
438
355
static int start_mandos_communication(const char *ip, uint16_t port,
439
356
                                      AvahiIfIndex if_index,
440
357
                                      mandos_context *mc){
441
358
  int ret, tcp_sd;
442
 
  union { struct sockaddr in; struct sockaddr_in6 in6; } to;
 
359
  struct sockaddr_in6 to;
443
360
  char *buffer = NULL;
444
361
  char *decrypted_buffer;
445
362
  size_t buffer_length = 0;
446
363
  size_t buffer_capacity = 0;
447
364
  ssize_t decrypted_buffer_size;
448
 
  size_t written;
 
365
  size_t written = 0;
449
366
  int retval = 0;
450
367
  char interface[IF_NAMESIZE];
451
368
  gnutls_session_t session;
452
 
  
453
 
  ret = init_gnutls_session (mc, &session);
454
 
  if (ret != 0){
455
 
    return -1;
456
 
  }
 
369
  gnutls_dh_params_t dh_params;
457
370
  
458
371
  if(debug){
459
 
    fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
460
 
            "\n", ip, port);
 
372
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
 
373
            ip, port);
461
374
  }
462
375
  
463
376
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
475
388
  }
476
389
  
477
390
  memset(&to,0,sizeof(to));     /* Spurious warning */
478
 
  to.in6.sin6_family = AF_INET6;
479
 
  /* It would be nice to have a way to detect if we were passed an
480
 
     IPv4 address here.   Now we assume an IPv6 address. */
481
 
  ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
 
391
  to.sin6_family = AF_INET6;
 
392
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
482
393
  if (ret < 0 ){
483
394
    perror("inet_pton");
484
395
    return -1;
487
398
    fprintf(stderr, "Bad address: %s\n", ip);
488
399
    return -1;
489
400
  }
490
 
  to.in6.sin6_port = htons(port);       /* Spurious warning */
 
401
  to.sin6_port = htons(port);   /* Spurious warning */
491
402
  
492
 
  to.in6.sin6_scope_id = (uint32_t)if_index;
 
403
  to.sin6_scope_id = (uint32_t)if_index;
493
404
  
494
405
  if(debug){
495
 
    fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
496
 
            port);
 
406
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
497
407
    char addrstr[INET6_ADDRSTRLEN] = "";
498
 
    if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
 
408
    if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
499
409
                 sizeof(addrstr)) == NULL){
500
410
      perror("inet_ntop");
501
411
    } else {
505
415
    }
506
416
  }
507
417
  
508
 
  ret = connect(tcp_sd, &to.in, sizeof(to));
 
418
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
509
419
  if (ret < 0){
510
420
    perror("connect");
511
421
    return -1;
512
422
  }
513
 
 
514
 
  const char *out = mandos_protocol_version;
515
 
  written = 0;
516
 
  while (true){
517
 
    size_t out_size = strlen(out);
518
 
    ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
519
 
                                   out_size - written));
520
 
    if (ret == -1){
521
 
      perror("write");
522
 
      retval = -1;
523
 
      goto mandos_end;
524
 
    }
525
 
    written += (size_t)ret;
526
 
    if(written < out_size){
527
 
      continue;
528
 
    } else {
529
 
      if (out == mandos_protocol_version){
530
 
        written = 0;
531
 
        out = "\r\n";
532
 
      } else {
533
 
        break;
534
 
      }
535
 
    }
 
423
  
 
424
  ret = initgnutls (mc, &session, &dh_params);
 
425
  if (ret != 0){
 
426
    retval = -1;
 
427
    return -1;
536
428
  }
537
 
 
 
429
  
 
430
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
 
431
  
538
432
  if(debug){
539
433
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
540
434
  }
541
435
  
542
 
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
543
 
 
544
 
  do{
545
 
    ret = gnutls_handshake (session);
546
 
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
436
  ret = gnutls_handshake (session);
547
437
  
548
438
  if (ret != GNUTLS_E_SUCCESS){
549
439
    if(debug){
550
 
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
440
      fprintf(stderr, "\n*** Handshake failed ***\n");
551
441
      gnutls_perror (ret);
552
442
    }
553
443
    retval = -1;
554
 
    goto mandos_end;
 
444
    goto exit;
555
445
  }
556
446
  
557
 
  /* Read OpenPGP packet that contains the wanted password */
 
447
  //Retrieve OpenPGP packet that contains the wanted password
558
448
  
559
449
  if(debug){
560
450
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
562
452
  }
563
453
 
564
454
  while(true){
565
 
    buffer_capacity = adjustbuffer(&buffer, buffer_length,
566
 
                                   buffer_capacity);
567
 
    if (buffer_capacity == 0){
568
 
      perror("adjustbuffer");
569
 
      retval = -1;
570
 
      goto mandos_end;
 
455
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
 
456
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
 
457
      if (buffer == NULL){
 
458
        perror("realloc");
 
459
        goto exit;
 
460
      }
 
461
      buffer_capacity += BUFFER_SIZE;
571
462
    }
572
463
    
573
464
    ret = gnutls_record_recv(session, buffer+buffer_length,
581
472
      case GNUTLS_E_AGAIN:
582
473
        break;
583
474
      case GNUTLS_E_REHANDSHAKE:
584
 
        do{
585
 
          ret = gnutls_handshake (session);
586
 
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
475
        ret = gnutls_handshake (session);
587
476
        if (ret < 0){
588
 
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
477
          fprintf(stderr, "\n*** Handshake failed ***\n");
589
478
          gnutls_perror (ret);
590
479
          retval = -1;
591
 
          goto mandos_end;
 
480
          goto exit;
592
481
        }
593
482
        break;
594
483
      default:
595
484
        fprintf(stderr, "Unknown error while reading data from"
596
 
                " encrypted session with Mandos server\n");
 
485
                " encrypted session with mandos server\n");
597
486
        retval = -1;
598
487
        gnutls_bye (session, GNUTLS_SHUT_RDWR);
599
 
        goto mandos_end;
 
488
        goto exit;
600
489
      }
601
490
    } else {
602
491
      buffer_length += (size_t) ret;
603
492
    }
604
493
  }
605
494
  
606
 
  if(debug){
607
 
    fprintf(stderr, "Closing TLS session\n");
608
 
  }
609
 
  
610
 
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
611
 
  
612
495
  if (buffer_length > 0){
613
496
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
614
497
                                               buffer_length,
615
498
                                               &decrypted_buffer,
616
499
                                               keydir);
617
500
    if (decrypted_buffer_size >= 0){
618
 
      written = 0;
619
501
      while(written < (size_t) decrypted_buffer_size){
620
502
        ret = (int)fwrite (decrypted_buffer + written, 1,
621
503
                           (size_t)decrypted_buffer_size - written,
635
517
      retval = -1;
636
518
    }
637
519
  }
638
 
  
639
 
  /* Shutdown procedure */
640
 
  
641
 
 mandos_end:
 
520
 
 
521
  //shutdown procedure
 
522
 
 
523
  if(debug){
 
524
    fprintf(stderr, "Closing TLS session\n");
 
525
  }
 
526
 
642
527
  free(buffer);
 
528
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
529
 exit:
643
530
  close(tcp_sd);
644
531
  gnutls_deinit (session);
 
532
  gnutls_certificate_free_credentials (mc->cred);
 
533
  gnutls_global_deinit ();
645
534
  return retval;
646
535
}
647
536
 
648
 
static void resolve_callback(AvahiSServiceResolver *r,
649
 
                             AvahiIfIndex interface,
650
 
                             AVAHI_GCC_UNUSED AvahiProtocol protocol,
651
 
                             AvahiResolverEvent event,
652
 
                             const char *name,
653
 
                             const char *type,
654
 
                             const char *domain,
655
 
                             const char *host_name,
656
 
                             const AvahiAddress *address,
657
 
                             uint16_t port,
658
 
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
659
 
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
660
 
                             flags,
661
 
                             void* userdata) {
 
537
static void resolve_callback( AvahiSServiceResolver *r,
 
538
                              AvahiIfIndex interface,
 
539
                              AVAHI_GCC_UNUSED AvahiProtocol protocol,
 
540
                              AvahiResolverEvent event,
 
541
                              const char *name,
 
542
                              const char *type,
 
543
                              const char *domain,
 
544
                              const char *host_name,
 
545
                              const AvahiAddress *address,
 
546
                              uint16_t port,
 
547
                              AVAHI_GCC_UNUSED AvahiStringList *txt,
 
548
                              AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
549
                              void* userdata) {
662
550
  mandos_context *mc = userdata;
663
551
  assert(r);                    /* Spurious warning */
664
552
  
668
556
  switch (event) {
669
557
  default:
670
558
  case AVAHI_RESOLVER_FAILURE:
671
 
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
672
 
            " of type '%s' in domain '%s': %s\n", name, type, domain,
 
559
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
 
560
            " type '%s' in domain '%s': %s\n", name, type, domain,
673
561
            avahi_strerror(avahi_server_errno(mc->server)));
674
562
    break;
675
563
    
678
566
      char ip[AVAHI_ADDRESS_STR_MAX];
679
567
      avahi_address_snprint(ip, sizeof(ip), address);
680
568
      if(debug){
681
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
682
 
                PRIu16 ") on port %d\n", name, host_name, ip,
683
 
                interface, port);
 
569
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
 
570
                " port %d\n", name, host_name, ip, port);
684
571
      }
685
572
      int ret = start_mandos_communication(ip, port, interface, mc);
686
573
      if (ret == 0){
698
585
                             const char *name,
699
586
                             const char *type,
700
587
                             const char *domain,
701
 
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
702
 
                             flags,
 
588
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
703
589
                             void* userdata) {
704
590
  mandos_context *mc = userdata;
705
591
  assert(b);                    /* Spurious warning */
711
597
  default:
712
598
  case AVAHI_BROWSER_FAILURE:
713
599
    
714
 
    fprintf(stderr, "(Avahi browser) %s\n",
 
600
    fprintf(stderr, "(Browser) %s\n",
715
601
            avahi_strerror(avahi_server_errno(mc->server)));
716
602
    avahi_simple_poll_quit(mc->simple_poll);
717
603
    return;
718
604
    
719
605
  case AVAHI_BROWSER_NEW:
720
 
    /* We ignore the returned Avahi resolver object. In the callback
721
 
       function we free it. If the Avahi server is terminated before
722
 
       the callback function is called the Avahi server will free the
723
 
       resolver for us. */
 
606
    /* We ignore the returned resolver object. In the callback
 
607
       function we free it. If the server is terminated before
 
608
       the callback function is called the server will free
 
609
       the resolver for us. */
724
610
    
725
 
    if (!(avahi_s_service_resolver_new(mc->server, interface,
726
 
                                       protocol, name, type, domain,
 
611
    if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
 
612
                                       type, domain,
727
613
                                       AVAHI_PROTO_INET6, 0,
728
614
                                       resolve_callback, mc)))
729
 
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
730
 
              name, avahi_strerror(avahi_server_errno(mc->server)));
 
615
      fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
 
616
              avahi_strerror(avahi_server_errno(mc->server)));
731
617
    break;
732
618
    
733
619
  case AVAHI_BROWSER_REMOVE:
735
621
    
736
622
  case AVAHI_BROWSER_ALL_FOR_NOW:
737
623
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
738
 
    if(debug){
739
 
      fprintf(stderr, "No Mandos server found, still searching...\n");
740
 
    }
741
624
    break;
742
625
  }
743
626
}
763
646
}
764
647
 
765
648
 
766
 
int main(int argc, char *argv[]){
 
649
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
650
    AvahiServerConfig config;
767
651
    AvahiSServiceBrowser *sb = NULL;
768
652
    int error;
769
653
    int ret;
770
 
    int exitcode = EXIT_SUCCESS;
 
654
    int debug_int;
 
655
    int returncode = EXIT_SUCCESS;
771
656
    const char *interface = "eth0";
772
657
    struct ifreq network;
773
658
    int sd;
774
 
    uid_t uid;
775
 
    gid_t gid;
776
659
    char *connect_to = NULL;
777
660
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
778
 
    const char *pubkeyfile = "pubkey.txt";
779
 
    const char *seckeyfile = "seckey.txt";
780
661
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
781
662
                          .dh_bits = 1024, .priority = "SECURE256"};
782
 
    bool gnutls_initalized = false;
783
663
    
784
 
    {
785
 
      struct argp_option options[] = {
786
 
        { .name = "debug", .key = 128,
787
 
          .doc = "Debug mode", .group = 3 },
788
 
        { .name = "connect", .key = 'c',
789
 
          .arg = "IP",
790
 
          .doc = "Connect directly to a sepcified mandos server",
791
 
          .group = 1 },
792
 
        { .name = "interface", .key = 'i',
793
 
          .arg = "INTERFACE",
794
 
          .doc = "Interface that Avahi will conntect through",
795
 
          .group = 1 },
796
 
        { .name = "keydir", .key = 'd',
797
 
          .arg = "KEYDIR",
798
 
          .doc = "Directory where the openpgp keyring is",
799
 
          .group = 1 },
800
 
        { .name = "seckey", .key = 's',
801
 
          .arg = "SECKEY",
802
 
          .doc = "Secret openpgp key for gnutls authentication",
803
 
          .group = 1 },
804
 
        { .name = "pubkey", .key = 'p',
805
 
          .arg = "PUBKEY",
806
 
          .doc = "Public openpgp key for gnutls authentication",
807
 
          .group = 2 },
808
 
        { .name = "dh-bits", .key = 129,
809
 
          .arg = "BITS",
810
 
          .doc = "dh-bits to use in gnutls communication",
811
 
          .group = 2 },
812
 
        { .name = "priority", .key = 130,
813
 
          .arg = "PRIORITY",
814
 
          .doc = "GNUTLS priority", .group = 1 },
815
 
        { .name = NULL }
816
 
      };
817
 
 
818
 
      
819
 
      error_t parse_opt (int key, char *arg,
820
 
                         struct argp_state *state) {
821
 
        /* Get the INPUT argument from `argp_parse', which we know is
822
 
           a pointer to our plugin list pointer. */
823
 
        switch (key) {
824
 
        case 128:
825
 
          debug = true;
826
 
          break;
827
 
        case 'c':
828
 
          connect_to = arg;
829
 
          break;
830
 
        case 'i':
831
 
          interface = arg;
832
 
          break;
833
 
        case 'd':
834
 
          keydir = arg;
835
 
          break;
836
 
        case 's':
837
 
          seckeyfile = arg;
838
 
          break;
839
 
        case 'p':
840
 
          pubkeyfile = arg;
841
 
          break;
842
 
        case 129:
843
 
          errno = 0;
844
 
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
845
 
          if (errno){
846
 
            perror("strtol");
847
 
            exit(EXIT_FAILURE);
848
 
          }
849
 
          break;
850
 
        case 130:
851
 
          mc.priority = arg;
852
 
          break;
853
 
        case ARGP_KEY_ARG:
854
 
          argp_usage (state);
855
 
          break;
856
 
          case ARGP_KEY_END:
857
 
            break;
858
 
        default:
859
 
          return ARGP_ERR_UNKNOWN;
 
664
    debug_int = debug ? 1 : 0;
 
665
    while (true){
 
666
      struct option long_options[] = {
 
667
        {"debug", no_argument, &debug_int, 1},
 
668
        {"connect", required_argument, NULL, 'c'},
 
669
        {"interface", required_argument, NULL, 'i'},
 
670
        {"keydir", required_argument, NULL, 'd'},
 
671
        {"seckey", required_argument, NULL, 's'},
 
672
        {"pubkey", required_argument, NULL, 'p'},
 
673
        {"dh-bits", required_argument, NULL, 'D'},
 
674
        {"priority", required_argument, NULL, 'P'},
 
675
        {0, 0, 0, 0} };
 
676
      
 
677
      int option_index = 0;
 
678
      ret = getopt_long (argc, argv, "i:", long_options,
 
679
                         &option_index);
 
680
      
 
681
      if (ret == -1){
 
682
        break;
 
683
      }
 
684
      
 
685
      switch(ret){
 
686
      case 0:
 
687
        break;
 
688
      case 'i':
 
689
        interface = optarg;
 
690
        break;
 
691
      case 'c':
 
692
        connect_to = optarg;
 
693
        break;
 
694
      case 'd':
 
695
        keydir = optarg;
 
696
        break;
 
697
      case 'p':
 
698
        pubkeyfile = optarg;
 
699
        break;
 
700
      case 's':
 
701
        seckeyfile = optarg;
 
702
        break;
 
703
      case 'D':
 
704
        errno = 0;
 
705
        mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
 
706
        if (errno){
 
707
          perror("strtol");
 
708
          exit(EXIT_FAILURE);
860
709
        }
861
 
        return 0;
862
 
      }
863
 
 
864
 
      struct argp argp = { .options = options, .parser = parse_opt,
865
 
                           .args_doc = "",
866
 
                           .doc = "Mandos client -- Get and decrypt"
867
 
                           " passwords from mandos server" };
868
 
      ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
869
 
      if (ret == ARGP_ERR_UNKNOWN){
870
 
        fprintf(stderr, "Unkown error while parsing arguments\n");
871
 
        exitcode = EXIT_FAILURE;
872
 
        goto end;
 
710
        break;
 
711
      case 'P':
 
712
        mc.priority = optarg;
 
713
        break;
 
714
      case '?':
 
715
      default:
 
716
        exit(EXIT_FAILURE);
873
717
      }
874
718
    }
875
 
      
 
719
    debug = debug_int ? true : false;
 
720
    
876
721
    pubkeyfile = combinepath(keydir, pubkeyfile);
877
722
    if (pubkeyfile == NULL){
878
723
      perror("combinepath");
879
 
      exitcode = EXIT_FAILURE;
880
 
      goto end;
 
724
      returncode = EXIT_FAILURE;
 
725
      goto exit;
881
726
    }
882
727
    
883
728
    seckeyfile = combinepath(keydir, seckeyfile);
884
729
    if (seckeyfile == NULL){
885
730
      perror("combinepath");
886
 
      goto end;
887
 
    }
888
 
 
889
 
    ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
890
 
    if (ret == -1){
891
 
      fprintf(stderr, "init_gnutls_global\n");
892
 
      goto end;
893
 
    } else {
894
 
      gnutls_initalized = true;
895
 
    }
896
 
 
897
 
    uid = getuid();
898
 
    gid = getgid();
899
 
 
900
 
    ret = setuid(uid);
901
 
    if (ret == -1){
902
 
      perror("setuid");
903
 
    }
904
 
    
905
 
    setgid(gid);
906
 
    if (ret == -1){
907
 
      perror("setgid");
 
731
      goto exit;
908
732
    }
909
733
    
910
734
    if_index = (AvahiIfIndex) if_nametoindex(interface);
919
743
      char *address = strrchr(connect_to, ':');
920
744
      if(address == NULL){
921
745
        fprintf(stderr, "No colon in address\n");
922
 
        exitcode = EXIT_FAILURE;
923
 
        goto end;
 
746
        exit(EXIT_FAILURE);
924
747
      }
925
748
      errno = 0;
926
749
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
927
750
      if(errno){
928
751
        perror("Bad port number");
929
 
        exitcode = EXIT_FAILURE;
930
 
        goto end;
 
752
        exit(EXIT_FAILURE);
931
753
      }
932
754
      *address = '\0';
933
755
      address = connect_to;
934
756
      ret = start_mandos_communication(address, port, if_index, &mc);
935
757
      if(ret < 0){
936
 
        exitcode = EXIT_FAILURE;
 
758
        exit(EXIT_FAILURE);
937
759
      } else {
938
 
        exitcode = EXIT_SUCCESS;
 
760
        exit(EXIT_SUCCESS);
939
761
      }
940
 
      goto end;
941
762
    }
942
763
    
943
 
    /* If the interface is down, bring it up */
944
 
    {
945
 
      sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
946
 
      if(sd < 0) {
947
 
        perror("socket");
948
 
        exitcode = EXIT_FAILURE;
949
 
        goto end;
950
 
      }
951
 
      strcpy(network.ifr_name, interface); /* Spurious warning */
952
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
764
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
765
    if(sd < 0) {
 
766
      perror("socket");
 
767
      returncode = EXIT_FAILURE;
 
768
      goto exit;
 
769
    }
 
770
    strcpy(network.ifr_name, interface); /* Spurious warning */
 
771
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
772
    if(ret == -1){
 
773
      
 
774
      perror("ioctl SIOCGIFFLAGS");
 
775
      returncode = EXIT_FAILURE;
 
776
      goto exit;
 
777
    }
 
778
    if((network.ifr_flags & IFF_UP) == 0){
 
779
      network.ifr_flags |= IFF_UP;
 
780
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
953
781
      if(ret == -1){
954
 
        perror("ioctl SIOCGIFFLAGS");
955
 
        exitcode = EXIT_FAILURE;
956
 
        goto end;
957
 
      }
958
 
      if((network.ifr_flags & IFF_UP) == 0){
959
 
        network.ifr_flags |= IFF_UP;
960
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
961
 
        if(ret == -1){
962
 
          perror("ioctl SIOCSIFFLAGS");
963
 
          exitcode = EXIT_FAILURE;
964
 
          goto end;
965
 
        }
966
 
      }
967
 
      close(sd);
 
782
        perror("ioctl SIOCSIFFLAGS");
 
783
        returncode = EXIT_FAILURE;
 
784
        goto exit;
 
785
      }
968
786
    }
 
787
    close(sd);
969
788
    
970
789
    if (not debug){
971
790
      avahi_set_log_function(empty_log);
972
791
    }
973
792
    
974
 
    /* Initialize the pseudo-RNG for Avahi */
 
793
    /* Initialize the psuedo-RNG */
975
794
    srand((unsigned int) time(NULL));
976
 
    
977
 
    /* Allocate main Avahi loop object */
978
 
    mc.simple_poll = avahi_simple_poll_new();
979
 
    if (mc.simple_poll == NULL) {
980
 
        fprintf(stderr, "Avahi: Failed to create simple poll"
981
 
                " object.\n");
982
 
        exitcode = EXIT_FAILURE;
983
 
        goto end;
984
 
    }
985
 
 
986
 
    {
987
 
      AvahiServerConfig config;
988
 
      /* Do not publish any local Zeroconf records */
989
 
      avahi_server_config_init(&config);
990
 
      config.publish_hinfo = 0;
991
 
      config.publish_addresses = 0;
992
 
      config.publish_workstation = 0;
993
 
      config.publish_domain = 0;
994
 
 
995
 
      /* Allocate a new server */
996
 
      mc.server = avahi_server_new(avahi_simple_poll_get
997
 
                                   (mc.simple_poll), &config, NULL,
998
 
                                   NULL, &error);
999
 
    
1000
 
      /* Free the Avahi configuration data */
1001
 
      avahi_server_config_free(&config);
1002
 
    }
1003
 
    
1004
 
    /* Check if creating the Avahi server object succeeded */
1005
 
    if (mc.server == NULL) {
1006
 
        fprintf(stderr, "Failed to create Avahi server: %s\n",
 
795
 
 
796
    /* Allocate main loop object */
 
797
    if (!(mc.simple_poll = avahi_simple_poll_new())) {
 
798
        fprintf(stderr, "Failed to create simple poll object.\n");
 
799
        returncode = EXIT_FAILURE;
 
800
        goto exit;
 
801
    }
 
802
 
 
803
    /* Do not publish any local records */
 
804
    avahi_server_config_init(&config);
 
805
    config.publish_hinfo = 0;
 
806
    config.publish_addresses = 0;
 
807
    config.publish_workstation = 0;
 
808
    config.publish_domain = 0;
 
809
 
 
810
    /* Allocate a new server */
 
811
    mc.server=avahi_server_new(avahi_simple_poll_get(mc.simple_poll),
 
812
                               &config, NULL, NULL, &error);
 
813
    
 
814
    /* Free the configuration data */
 
815
    avahi_server_config_free(&config);
 
816
    
 
817
    /* Check if creating the server object succeeded */
 
818
    if (!mc.server) {
 
819
        fprintf(stderr, "Failed to create server: %s\n",
1007
820
                avahi_strerror(error));
1008
 
        exitcode = EXIT_FAILURE;
1009
 
        goto end;
 
821
        returncode = EXIT_FAILURE;
 
822
        goto exit;
1010
823
    }
1011
824
    
1012
 
    /* Create the Avahi service browser */
 
825
    /* Create the service browser */
1013
826
    sb = avahi_s_service_browser_new(mc.server, if_index,
1014
827
                                     AVAHI_PROTO_INET6,
1015
828
                                     "_mandos._tcp", NULL, 0,
1016
829
                                     browse_callback, &mc);
1017
 
    if (sb == NULL) {
 
830
    if (!sb) {
1018
831
        fprintf(stderr, "Failed to create service browser: %s\n",
1019
832
                avahi_strerror(avahi_server_errno(mc.server)));
1020
 
        exitcode = EXIT_FAILURE;
1021
 
        goto end;
 
833
        returncode = EXIT_FAILURE;
 
834
        goto exit;
1022
835
    }
1023
836
    
1024
837
    /* Run the main loop */
1025
838
 
1026
839
    if (debug){
1027
 
      fprintf(stderr, "Starting Avahi loop search\n");
 
840
      fprintf(stderr, "Starting avahi loop search\n");
1028
841
    }
1029
842
    
1030
843
    avahi_simple_poll_loop(mc.simple_poll);
1031
844
    
1032
 
 end:
 
845
 exit:
1033
846
 
1034
847
    if (debug){
1035
848
      fprintf(stderr, "%s exiting\n", argv[0]);
1036
849
    }
1037
850
    
1038
851
    /* Cleanup things */
1039
 
    if (sb != NULL)
 
852
    if (sb)
1040
853
        avahi_s_service_browser_free(sb);
1041
854
    
1042
 
    if (mc.server != NULL)
 
855
    if (mc.server)
1043
856
        avahi_server_free(mc.server);
1044
857
 
1045
 
    if (mc.simple_poll != NULL)
 
858
    if (mc.simple_poll)
1046
859
        avahi_simple_poll_free(mc.simple_poll);
1047
860
    free(pubkeyfile);
1048
861
    free(seckeyfile);
1049
 
 
1050
 
    if (gnutls_initalized){
1051
 
      gnutls_certificate_free_credentials(mc.cred);
1052
 
      gnutls_global_deinit ();
1053
 
    }
1054
862
    
1055
 
    return exitcode;
 
863
    return returncode;
1056
864
}