/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-08-02 21:06:12 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080802210612-4c1waup4z0f66ya7
Non-tested commit for merge purposes.

* plugbasedclient.c (getplugin, addargument, set_cloexec): Made static.

* plugins.d/passprompt.c (termination_handler): Made static.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Mandos client - get and decrypt data from a Mandos server
 
4
 *
 
5
 * This program is partly derived from an example program for an Avahi
 
6
 * service browser, downloaded from
 
7
 * <http://avahi.org/browser/examples/core-browse-services.c>.  This
 
8
 * includes the following functions: "resolve_callback",
 
9
 * "browse_callback", and parts of "main".
 
10
 * 
 
11
 * Everything else is
 
12
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
13
 * 
 
14
 * This program is free software: you can redistribute it and/or
 
15
 * modify it under the terms of the GNU General Public License as
 
16
 * published by the Free Software Foundation, either version 3 of the
 
17
 * License, or (at your option) any later version.
 
18
 * 
 
19
 * This program is distributed in the hope that it will be useful, but
 
20
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
22
 * General Public License for more details.
 
23
 * 
 
24
 * You should have received a copy of the GNU General Public License
 
25
 * along with this program.  If not, see
 
26
 * <http://www.gnu.org/licenses/>.
 
27
 * 
 
28
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
29
 */
 
30
 
 
31
/* Needed by GPGME, specifically gpgme_data_seek() */
 
32
#define _LARGEFILE_SOURCE
 
33
#define _FILE_OFFSET_BITS 64
 
34
 
 
35
#include <stdio.h>
 
36
#include <assert.h>
 
37
#include <stdlib.h>
 
38
#include <time.h>
 
39
#include <net/if.h>             /* if_nametoindex */
 
40
 
 
41
#include <avahi-core/core.h>
 
42
#include <avahi-core/lookup.h>
 
43
#include <avahi-core/log.h>
 
44
#include <avahi-common/simple-watch.h>
 
45
#include <avahi-common/malloc.h>
 
46
#include <avahi-common/error.h>
 
47
 
 
48
//mandos client part
 
49
#include <sys/types.h>          /* socket(), inet_pton() */
 
50
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
51
                                   struct in6_addr, inet_pton() */
 
52
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
 
53
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
 
54
 
 
55
#include <unistd.h>             /* close() */
 
56
#include <netinet/in.h>
 
57
#include <stdbool.h>            /* true */
 
58
#include <string.h>             /* memset */
 
59
#include <arpa/inet.h>          /* inet_pton() */
 
60
#include <iso646.h>             /* not */
 
61
 
 
62
// gpgme
 
63
#include <errno.h>              /* perror() */
 
64
#include <gpgme.h>
 
65
 
 
66
// getopt_long
 
67
#include <getopt.h>
 
68
 
 
69
#define BUFFER_SIZE 256
 
70
 
 
71
static int dh_bits = 1024;
 
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
 
 
77
bool debug = false;
 
78
 
 
79
/* Used for  */
 
80
typedef struct {
 
81
  gnutls_session_t session;
 
82
  gnutls_certificate_credentials_t cred;
 
83
  gnutls_dh_params_t dh_params;
 
84
} encrypted_session;
 
85
 
 
86
 
 
87
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
 
88
                                   char **new_packet,
 
89
                                   const char *homedir){
 
90
  gpgme_data_t dh_crypto, dh_plain;
 
91
  gpgme_ctx_t ctx;
 
92
  gpgme_error_t rc;
 
93
  ssize_t ret;
 
94
  ssize_t new_packet_capacity = 0;
 
95
  ssize_t new_packet_length = 0;
 
96
  gpgme_engine_info_t engine_info;
 
97
 
 
98
  if (debug){
 
99
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
 
100
  }
 
101
  
 
102
  /* Init GPGME */
 
103
  gpgme_check_version(NULL);
 
104
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
105
  if (rc != GPG_ERR_NO_ERROR){
 
106
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
107
            gpgme_strsource(rc), gpgme_strerror(rc));
 
108
    return -1;
 
109
  }
 
110
  
 
111
  /* Set GPGME home directory */
 
112
  rc = gpgme_get_engine_info (&engine_info);
 
113
  if (rc != GPG_ERR_NO_ERROR){
 
114
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
115
            gpgme_strsource(rc), gpgme_strerror(rc));
 
116
    return -1;
 
117
  }
 
118
  while(engine_info != NULL){
 
119
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
 
120
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
 
121
                            engine_info->file_name, homedir);
 
122
      break;
 
123
    }
 
124
    engine_info = engine_info->next;
 
125
  }
 
126
  if(engine_info == NULL){
 
127
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
 
128
    return -1;
 
129
  }
 
130
  
 
131
  /* Create new GPGME data buffer from packet buffer */
 
132
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
 
133
  if (rc != GPG_ERR_NO_ERROR){
 
134
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
135
            gpgme_strsource(rc), gpgme_strerror(rc));
 
136
    return -1;
 
137
  }
 
138
  
 
139
  /* Create new empty GPGME data buffer for the plaintext */
 
140
  rc = gpgme_data_new(&dh_plain);
 
141
  if (rc != GPG_ERR_NO_ERROR){
 
142
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
143
            gpgme_strsource(rc), gpgme_strerror(rc));
 
144
    return -1;
 
145
  }
 
146
  
 
147
  /* Create new GPGME "context" */
 
148
  rc = gpgme_new(&ctx);
 
149
  if (rc != GPG_ERR_NO_ERROR){
 
150
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
151
            gpgme_strsource(rc), gpgme_strerror(rc));
 
152
    return -1;
 
153
  }
 
154
  
 
155
  /* Decrypt data from the FILE pointer to the plaintext data
 
156
     buffer */
 
157
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
 
158
  if (rc != GPG_ERR_NO_ERROR){
 
159
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
160
            gpgme_strsource(rc), gpgme_strerror(rc));
 
161
    return -1;
 
162
  }
 
163
 
 
164
  if(debug){
 
165
    fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
 
166
  }
 
167
 
 
168
  if (debug){
 
169
    gpgme_decrypt_result_t result;
 
170
    result = gpgme_op_decrypt_result(ctx);
 
171
    if (result == NULL){
 
172
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
173
    } else {
 
174
      fprintf(stderr, "Unsupported algorithm: %s\n",
 
175
              result->unsupported_algorithm);
 
176
      fprintf(stderr, "Wrong key usage: %d\n",
 
177
              result->wrong_key_usage);
 
178
      if(result->file_name != NULL){
 
179
        fprintf(stderr, "File name: %s\n", result->file_name);
 
180
      }
 
181
      gpgme_recipient_t recipient;
 
182
      recipient = result->recipients;
 
183
      if(recipient){
 
184
        while(recipient != NULL){
 
185
          fprintf(stderr, "Public key algorithm: %s\n",
 
186
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
187
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
188
          fprintf(stderr, "Secret key available: %s\n",
 
189
                  recipient->status == GPG_ERR_NO_SECKEY
 
190
                  ? "No" : "Yes");
 
191
          recipient = recipient->next;
 
192
        }
 
193
      }
 
194
    }
 
195
  }
 
196
  
 
197
  /* Delete the GPGME FILE pointer cryptotext data buffer */
 
198
  gpgme_data_release(dh_crypto);
 
199
  
 
200
  /* Seek back to the beginning of the GPGME plaintext data buffer */
 
201
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
202
    perror("pgpme_data_seek");
 
203
  }
 
204
  
 
205
  *new_packet = 0;
 
206
  while(true){
 
207
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
 
208
      *new_packet = realloc(*new_packet,
 
209
                            (unsigned int)new_packet_capacity
 
210
                            + BUFFER_SIZE);
 
211
      if (*new_packet == NULL){
 
212
        perror("realloc");
 
213
        return -1;
 
214
      }
 
215
      new_packet_capacity += BUFFER_SIZE;
 
216
    }
 
217
    
 
218
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
 
219
                          BUFFER_SIZE);
 
220
    /* Print the data, if any */
 
221
    if (ret == 0){
 
222
      break;
 
223
    }
 
224
    if(ret < 0){
 
225
      perror("gpgme_data_read");
 
226
      return -1;
 
227
    }
 
228
    new_packet_length += ret;
 
229
  }
 
230
 
 
231
  /* FIXME: check characters before printing to screen so to not print
 
232
     terminal control characters */
 
233
  /*   if(debug){ */
 
234
  /*     fprintf(stderr, "decrypted password is: "); */
 
235
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
 
236
  /*     fprintf(stderr, "\n"); */
 
237
  /*   } */
 
238
  
 
239
  /* Delete the GPGME plaintext data buffer */
 
240
  gpgme_data_release(dh_plain);
 
241
  return new_packet_length;
 
242
}
 
243
 
 
244
static const char * safer_gnutls_strerror (int value) {
 
245
  const char *ret = gnutls_strerror (value);
 
246
  if (ret == NULL)
 
247
    ret = "(unknown)";
 
248
  return ret;
 
249
}
 
250
 
 
251
static void debuggnutls(__attribute__((unused)) int level,
 
252
                        const char* string){
 
253
  fprintf(stderr, "%s", string);
 
254
}
 
255
 
 
256
static int initgnutls(encrypted_session *es){
 
257
  const char *err;
 
258
  int ret;
 
259
  
 
260
  if(debug){
 
261
    fprintf(stderr, "Initializing GnuTLS\n");
 
262
  }
 
263
 
 
264
  if ((ret = gnutls_global_init ())
 
265
      != GNUTLS_E_SUCCESS) {
 
266
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
267
    return -1;
 
268
  }
 
269
 
 
270
  if (debug){
 
271
    gnutls_global_set_log_level(11);
 
272
    gnutls_global_set_log_function(debuggnutls);
 
273
  }
 
274
  
 
275
  /* openpgp credentials */
 
276
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
 
277
      != GNUTLS_E_SUCCESS) {
 
278
    fprintf (stderr, "memory error: %s\n",
 
279
             safer_gnutls_strerror(ret));
 
280
    return -1;
 
281
  }
 
282
  
 
283
  if(debug){
 
284
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
 
285
            " and keyfile %s as GnuTLS credentials\n", pubkeyfile,
 
286
            seckeyfile);
 
287
  }
 
288
  
 
289
  ret = gnutls_certificate_set_openpgp_key_file
 
290
    (es->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
 
291
  if (ret != GNUTLS_E_SUCCESS) {
 
292
    fprintf
 
293
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
 
294
       " '%s')\n",
 
295
       ret, pubkeyfile, seckeyfile);
 
296
    fprintf(stdout, "The Error is: %s\n",
 
297
            safer_gnutls_strerror(ret));
 
298
    return -1;
 
299
  }
 
300
  
 
301
  //GnuTLS server initialization
 
302
  if ((ret = gnutls_dh_params_init (&es->dh_params))
 
303
      != GNUTLS_E_SUCCESS) {
 
304
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
 
305
             safer_gnutls_strerror(ret));
 
306
    return -1;
 
307
  }
 
308
  
 
309
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, dh_bits))
 
310
      != GNUTLS_E_SUCCESS) {
 
311
    fprintf (stderr, "Error in prime generation: %s\n",
 
312
             safer_gnutls_strerror(ret));
 
313
    return -1;
 
314
  }
 
315
  
 
316
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
 
317
  
 
318
  // GnuTLS session creation
 
319
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
 
320
      != GNUTLS_E_SUCCESS){
 
321
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
 
322
            safer_gnutls_strerror(ret));
 
323
  }
 
324
  
 
325
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
 
326
      != GNUTLS_E_SUCCESS) {
 
327
    fprintf(stderr, "Syntax error at: %s\n", err);
 
328
    fprintf(stderr, "GnuTLS error: %s\n",
 
329
            safer_gnutls_strerror(ret));
 
330
    return -1;
 
331
  }
 
332
  
 
333
  if ((ret = gnutls_credentials_set
 
334
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
 
335
      != GNUTLS_E_SUCCESS) {
 
336
    fprintf(stderr, "Error setting a credentials set: %s\n",
 
337
            safer_gnutls_strerror(ret));
 
338
    return -1;
 
339
  }
 
340
  
 
341
  /* ignore client certificate if any. */
 
342
  gnutls_certificate_server_set_request (es->session,
 
343
                                         GNUTLS_CERT_IGNORE);
 
344
  
 
345
  gnutls_dh_set_prime_bits (es->session, dh_bits);
 
346
  
 
347
  return 0;
 
348
}
 
349
 
 
350
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
351
                      __attribute__((unused)) const char *txt){}
 
352
 
 
353
static int start_mandos_communication(const char *ip, uint16_t port,
 
354
                                      AvahiIfIndex if_index){
 
355
  int ret, tcp_sd;
 
356
  struct sockaddr_in6 to;
 
357
  encrypted_session es;
 
358
  char *buffer = NULL;
 
359
  char *decrypted_buffer;
 
360
  size_t buffer_length = 0;
 
361
  size_t buffer_capacity = 0;
 
362
  ssize_t decrypted_buffer_size;
 
363
  size_t written = 0;
 
364
  int retval = 0;
 
365
  char interface[IF_NAMESIZE];
 
366
  
 
367
  if(debug){
 
368
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
 
369
            ip, port);
 
370
  }
 
371
  
 
372
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
 
373
  if(tcp_sd < 0) {
 
374
    perror("socket");
 
375
    return -1;
 
376
  }
 
377
  
 
378
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
379
    if(debug){
 
380
      perror("if_indextoname");
 
381
    }
 
382
    return -1;
 
383
  }
 
384
  
 
385
  if(debug){
 
386
    fprintf(stderr, "Binding to interface %s\n", interface);
 
387
  }
 
388
  
 
389
  memset(&to,0,sizeof(to));     /* Spurious warning */
 
390
  to.sin6_family = AF_INET6;
 
391
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
 
392
  if (ret < 0 ){
 
393
    perror("inet_pton");
 
394
    return -1;
 
395
  }  
 
396
  if(ret == 0){
 
397
    fprintf(stderr, "Bad address: %s\n", ip);
 
398
    return -1;
 
399
  }
 
400
  to.sin6_port = htons(port);   /* Spurious warning */
 
401
  
 
402
  to.sin6_scope_id = (uint32_t)if_index;
 
403
  
 
404
  if(debug){
 
405
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
 
406
    char addrstr[INET6_ADDRSTRLEN] = "";
 
407
    if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
 
408
                 sizeof(addrstr)) == NULL){
 
409
      perror("inet_ntop");
 
410
    } else {
 
411
      if(strcmp(addrstr, ip) != 0){
 
412
        fprintf(stderr, "Canonical address form: %s\n",
 
413
                addrstr, ntohs(to.sin6_port));
 
414
      }
 
415
    }
 
416
  }
 
417
  
 
418
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
 
419
  if (ret < 0){
 
420
    perror("connect");
 
421
    return -1;
 
422
  }
 
423
  
 
424
  ret = initgnutls (&es);
 
425
  if (ret != 0){
 
426
    retval = -1;
 
427
    return -1;
 
428
  }
 
429
  
 
430
  gnutls_transport_set_ptr (es.session,
 
431
                            (gnutls_transport_ptr_t) tcp_sd);
 
432
  
 
433
  if(debug){
 
434
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
435
  }
 
436
  
 
437
  ret = gnutls_handshake (es.session);
 
438
  
 
439
  if (ret != GNUTLS_E_SUCCESS){
 
440
    if(debug){
 
441
      fprintf(stderr, "\n*** Handshake failed ***\n");
 
442
      gnutls_perror (ret);
 
443
    }
 
444
    retval = -1;
 
445
    goto exit;
 
446
  }
 
447
  
 
448
  //Retrieve OpenPGP packet that contains the wanted password
 
449
  
 
450
  if(debug){
 
451
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
 
452
            ip);
 
453
  }
 
454
 
 
455
  while(true){
 
456
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
 
457
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
 
458
      if (buffer == NULL){
 
459
        perror("realloc");
 
460
        goto exit;
 
461
      }
 
462
      buffer_capacity += BUFFER_SIZE;
 
463
    }
 
464
    
 
465
    ret = gnutls_record_recv
 
466
      (es.session, buffer+buffer_length, BUFFER_SIZE);
 
467
    if (ret == 0){
 
468
      break;
 
469
    }
 
470
    if (ret < 0){
 
471
      switch(ret){
 
472
      case GNUTLS_E_INTERRUPTED:
 
473
      case GNUTLS_E_AGAIN:
 
474
        break;
 
475
      case GNUTLS_E_REHANDSHAKE:
 
476
        ret = gnutls_handshake (es.session);
 
477
        if (ret < 0){
 
478
          fprintf(stderr, "\n*** Handshake failed ***\n");
 
479
          gnutls_perror (ret);
 
480
          retval = -1;
 
481
          goto exit;
 
482
        }
 
483
        break;
 
484
      default:
 
485
        fprintf(stderr, "Unknown error while reading data from"
 
486
                " encrypted session with mandos server\n");
 
487
        retval = -1;
 
488
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
 
489
        goto exit;
 
490
      }
 
491
    } else {
 
492
      buffer_length += (size_t) ret;
 
493
    }
 
494
  }
 
495
  
 
496
  if (buffer_length > 0){
 
497
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
498
                                               buffer_length,
 
499
                                               &decrypted_buffer,
 
500
                                               keydir);
 
501
    if (decrypted_buffer_size >= 0){
 
502
      while(written < (size_t) decrypted_buffer_size){
 
503
        ret = (int)fwrite (decrypted_buffer + written, 1,
 
504
                           (size_t)decrypted_buffer_size - written,
 
505
                           stdout);
 
506
        if(ret == 0 and ferror(stdout)){
 
507
          if(debug){
 
508
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
509
                    strerror(errno));
 
510
          }
 
511
          retval = -1;
 
512
          break;
 
513
        }
 
514
        written += (size_t)ret;
 
515
      }
 
516
      free(decrypted_buffer);
 
517
    } else {
 
518
      retval = -1;
 
519
    }
 
520
  }
 
521
 
 
522
  //shutdown procedure
 
523
 
 
524
  if(debug){
 
525
    fprintf(stderr, "Closing TLS session\n");
 
526
  }
 
527
 
 
528
  free(buffer);
 
529
  gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
 
530
 exit:
 
531
  close(tcp_sd);
 
532
  gnutls_deinit (es.session);
 
533
  gnutls_certificate_free_credentials (es.cred);
 
534
  gnutls_global_deinit ();
 
535
  return retval;
 
536
}
 
537
 
 
538
static AvahiSimplePoll *simple_poll = NULL;
 
539
static AvahiServer *server = NULL;
 
540
 
 
541
static void resolve_callback(
 
542
    AvahiSServiceResolver *r,
 
543
    AvahiIfIndex interface,
 
544
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
 
545
    AvahiResolverEvent event,
 
546
    const char *name,
 
547
    const char *type,
 
548
    const char *domain,
 
549
    const char *host_name,
 
550
    const AvahiAddress *address,
 
551
    uint16_t port,
 
552
    AVAHI_GCC_UNUSED AvahiStringList *txt,
 
553
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
554
    AVAHI_GCC_UNUSED void* userdata) {
 
555
    
 
556
  assert(r);                    /* Spurious warning */
 
557
  
 
558
  /* Called whenever a service has been resolved successfully or
 
559
     timed out */
 
560
  
 
561
  switch (event) {
 
562
  default:
 
563
  case AVAHI_RESOLVER_FAILURE:
 
564
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
 
565
            " type '%s' in domain '%s': %s\n", name, type, domain,
 
566
            avahi_strerror(avahi_server_errno(server)));
 
567
    break;
 
568
    
 
569
  case AVAHI_RESOLVER_FOUND:
 
570
    {
 
571
      char ip[AVAHI_ADDRESS_STR_MAX];
 
572
      avahi_address_snprint(ip, sizeof(ip), address);
 
573
      if(debug){
 
574
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
 
575
                " port %d\n", name, host_name, ip, port);
 
576
      }
 
577
      int ret = start_mandos_communication(ip, port, interface);
 
578
      if (ret == 0){
 
579
        exit(EXIT_SUCCESS);
 
580
      }
 
581
    }
 
582
  }
 
583
  avahi_s_service_resolver_free(r);
 
584
}
 
585
 
 
586
static void browse_callback(
 
587
    AvahiSServiceBrowser *b,
 
588
    AvahiIfIndex interface,
 
589
    AvahiProtocol protocol,
 
590
    AvahiBrowserEvent event,
 
591
    const char *name,
 
592
    const char *type,
 
593
    const char *domain,
 
594
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
595
    void* userdata) {
 
596
    
 
597
    AvahiServer *s = userdata;
 
598
    assert(b);                  /* Spurious warning */
 
599
    
 
600
    /* Called whenever a new services becomes available on the LAN or
 
601
       is removed from the LAN */
 
602
    
 
603
    switch (event) {
 
604
    default:
 
605
    case AVAHI_BROWSER_FAILURE:
 
606
      
 
607
      fprintf(stderr, "(Browser) %s\n",
 
608
              avahi_strerror(avahi_server_errno(server)));
 
609
      avahi_simple_poll_quit(simple_poll);
 
610
      return;
 
611
      
 
612
    case AVAHI_BROWSER_NEW:
 
613
      /* We ignore the returned resolver object. In the callback
 
614
         function we free it. If the server is terminated before
 
615
         the callback function is called the server will free
 
616
         the resolver for us. */
 
617
      
 
618
      if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
 
619
                                         type, domain,
 
620
                                         AVAHI_PROTO_INET6, 0,
 
621
                                         resolve_callback, s)))
 
622
        fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
 
623
                avahi_strerror(avahi_server_errno(s)));
 
624
      break;
 
625
      
 
626
    case AVAHI_BROWSER_REMOVE:
 
627
      break;
 
628
      
 
629
    case AVAHI_BROWSER_ALL_FOR_NOW:
 
630
    case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
631
      break;
 
632
    }
 
633
}
 
634
 
 
635
/* Combines file name and path and returns the malloced new
 
636
   string. some sane checks could/should be added */
 
637
static const char *combinepath(const char *first, const char *second){
 
638
  size_t f_len = strlen(first);
 
639
  size_t s_len = strlen(second);
 
640
  char *tmp = malloc(f_len + s_len + 2);
 
641
  if (tmp == NULL){
 
642
    return NULL;
 
643
  }
 
644
  if(f_len > 0){
 
645
    memcpy(tmp, first, f_len);
 
646
  }
 
647
  tmp[f_len] = '/';
 
648
  if(s_len > 0){
 
649
    memcpy(tmp + f_len + 1, second, s_len);
 
650
  }
 
651
  tmp[f_len + 1 + s_len] = '\0';
 
652
  return tmp;
 
653
}
 
654
 
 
655
 
 
656
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
657
    AvahiServerConfig config;
 
658
    AvahiSServiceBrowser *sb = NULL;
 
659
    int error;
 
660
    int ret;
 
661
    int debug_int = 0;
 
662
    int returncode = EXIT_SUCCESS;
 
663
    const char *interface = NULL;
 
664
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
665
    char *connect_to = NULL;
 
666
    
 
667
    debug_int = debug ? 1 : 0;
 
668
    while (true){
 
669
      static struct option long_options[] = {
 
670
        {"debug", no_argument, &debug_int, 1},
 
671
        {"connect", required_argument, NULL, 'C'},
 
672
        {"interface", required_argument, NULL, 'i'},
 
673
        {"keydir", required_argument, NULL, 'd'},
 
674
        {"seckey", required_argument, NULL, 'c'},
 
675
        {"pubkey", required_argument, NULL, 'k'},
 
676
        {"dh-bits", required_argument, NULL, 'D'},
 
677
        {0, 0, 0, 0} };
 
678
      
 
679
      int option_index = 0;
 
680
      ret = getopt_long (argc, argv, "i:", long_options,
 
681
                         &option_index);
 
682
      
 
683
      if (ret == -1){
 
684
        break;
 
685
      }
 
686
      
 
687
      switch(ret){
 
688
      case 0:
 
689
        break;
 
690
      case 'i':
 
691
        interface = optarg;
 
692
        break;
 
693
      case 'C':
 
694
        connect_to = optarg;
 
695
        break;
 
696
      case 'd':
 
697
        keydir = optarg;
 
698
        break;
 
699
      case 'c':
 
700
        pubkeyfile = optarg;
 
701
        break;
 
702
      case 'k':
 
703
        seckeyfile = optarg;
 
704
        break;
 
705
      case 'D':
 
706
        dh_bits = atoi(optarg);
 
707
        break;
 
708
      case '?':
 
709
        break
 
710
      default:
 
711
        exit(EXIT_FAILURE);
 
712
      }
 
713
    }
 
714
    debug = debug_int ? true : false;
 
715
    
 
716
    pubkeyfile = combinepath(keydir, pubkeyfile);
 
717
    if (pubkeyfile == NULL){
 
718
      perror("combinepath");
 
719
      goto exit;
 
720
    }
 
721
    
 
722
    if(interface != NULL){
 
723
      if_index = (AvahiIfIndex) if_nametoindex(interface);
 
724
      if(if_index == 0){
 
725
        fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
726
        exit(EXIT_FAILURE);
 
727
      }
 
728
    }
 
729
    
 
730
    if(connect_to != NULL){
 
731
      /* Connect directly, do not use Zeroconf */
 
732
      /* (Mainly meant for debugging) */
 
733
      char *address = strrchr(connect_to, ':');
 
734
      if(address == NULL){
 
735
        fprintf(stderr, "No colon in address\n");
 
736
        exit(EXIT_FAILURE);
 
737
      }
 
738
      errno = 0;
 
739
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
 
740
      if(errno){
 
741
        perror("Bad port number");
 
742
        exit(EXIT_FAILURE);
 
743
      }
 
744
      *address = '\0';
 
745
      address = connect_to;
 
746
      ret = start_mandos_communication(address, port, if_index);
 
747
      if(ret < 0){
 
748
        exit(EXIT_FAILURE);
 
749
      } else {
 
750
        exit(EXIT_SUCCESS);
 
751
      }
 
752
    }
 
753
    
 
754
    seckeyfile = combinepath(keydir, seckeyfile);
 
755
    if (seckeyfile == NULL){
 
756
      perror("combinepath");
 
757
      goto exit;
 
758
    }
 
759
    
 
760
    if (not debug){
 
761
      avahi_set_log_function(empty_log);
 
762
    }
 
763
    
 
764
    /* Initialize the psuedo-RNG */
 
765
    srand((unsigned int) time(NULL));
 
766
 
 
767
    /* Allocate main loop object */
 
768
    if (!(simple_poll = avahi_simple_poll_new())) {
 
769
        fprintf(stderr, "Failed to create simple poll object.\n");
 
770
        
 
771
        goto exit;
 
772
    }
 
773
 
 
774
    /* Do not publish any local records */
 
775
    avahi_server_config_init(&config);
 
776
    config.publish_hinfo = 0;
 
777
    config.publish_addresses = 0;
 
778
    config.publish_workstation = 0;
 
779
    config.publish_domain = 0;
 
780
 
 
781
    /* Allocate a new server */
 
782
    server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
783
                              &config, NULL, NULL, &error);
 
784
 
 
785
    /* Free the configuration data */
 
786
    avahi_server_config_free(&config);
 
787
 
 
788
    /* Check if creating the server object succeeded */
 
789
    if (!server) {
 
790
        fprintf(stderr, "Failed to create server: %s\n",
 
791
                avahi_strerror(error));
 
792
        returncode = EXIT_FAILURE;
 
793
        goto exit;
 
794
    }
 
795
    
 
796
    /* Create the service browser */
 
797
    sb = avahi_s_service_browser_new(server, if_index,
 
798
                                     AVAHI_PROTO_INET6,
 
799
                                     "_mandos._tcp", NULL, 0,
 
800
                                     browse_callback, server);
 
801
    if (!sb) {
 
802
        fprintf(stderr, "Failed to create service browser: %s\n",
 
803
                avahi_strerror(avahi_server_errno(server)));
 
804
        returncode = EXIT_FAILURE;
 
805
        goto exit;
 
806
    }
 
807
    
 
808
    /* Run the main loop */
 
809
 
 
810
    if (debug){
 
811
      fprintf(stderr, "Starting avahi loop search\n");
 
812
    }
 
813
    
 
814
    avahi_simple_poll_loop(simple_poll);
 
815
    
 
816
 exit:
 
817
 
 
818
    if (debug){
 
819
      fprintf(stderr, "%s exiting\n", argv[0]);
 
820
    }
 
821
    
 
822
    /* Cleanup things */
 
823
    if (sb)
 
824
        avahi_s_service_browser_free(sb);
 
825
    
 
826
    if (server)
 
827
        avahi_server_free(server);
 
828
 
 
829
    if (simple_poll)
 
830
        avahi_simple_poll_free(simple_poll);
 
831
    free(pubkeyfile);
 
832
    free(seckeyfile);
 
833
    
 
834
    return returncode;
 
835
}