/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: Björn Påhlsson
  • Date: 2008-08-02 14:48:45 UTC
  • mto: (237.7.1 mandos) (24.1.154 mandos)
  • mto: This revision was merged to the branch mainline in revision 38.
  • Revision ID: belorn@braxen-20080802144845-sd6z98g9poztxffs
plugbasedclient
        change uid to nobody:nogroup as default for all plugins

mandosclient
        Takes up the interface if needed

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