/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-07-21 15:34:44 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080721153444-lugbjkj1oq65ugq3
* Makefile (CFLAGS): Changed to use $(WARN), $(DEBUG), $(COVERAGE) and
                     $(LANGUAGE).
  (WARN, DEBUG, COVERAGE, LANGUAGE): New.
  (LDFLAGS): New; use $(COVERAGE)

* plugbasedclient.c: Added copyright header.
  (process.buffer_size, process.buffer_length): Changed to "size_t".
  (main): Cast arguments to malloc and realloc.  Detect read errors
          from processes.

* mandosclient.c: Added copyright header.
  (interface): Moved to inside "main".
  (gpg_packet_decrypt): Renamed to "pgp_packet_decrypt"; all callers
                        changed.  Changed "new_packet_capacity" and
                        "new_packet_length" to be ssize_t.  Cast
                        arguments to realloc.
  (debuggnutls): Attribute "level" argument as unused.
  (empty_log): Attribute "level" and "txt" arguments as unused.
  (start_mandos_communication): New argument "if_index".  Bug fix:
                                check ret, no tcp_sd, for errors from
                                setsockopt.  Use "if_index" directly
                                instead of looking up the index.  Loop
                                around fwrite until all data is written.
  (resolve_callback): Attribute "txt", and "flags" as usused.  Added
                      default case to switch.  Also show server host
                      name.  Call start_mandos_communication with
                      "interface".
  (browse_callback): Added default case to switch.
  (main): Variable "interface" moved here.  Cast "srand" argument.
          Bug fix: Call avahi_s_service_browser_new with index of
          "interface", not "eth0".

* passprompt.c: Added copyright header.
  (termination_handler): Attribute "signum" argument as unused.

Show diffs side-by-side

added added

removed removed

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