/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
1
 
/***
2
 
  This file is part of avahi.
3
 
 
4
 
  avahi is free software; you can redistribute it and/or modify it
5
 
  under the terms of the GNU Lesser General Public License as
6
 
  published by the Free Software Foundation; either version 2.1 of the
7
 
  License, or (at your option) any later version.
8
 
 
9
 
  avahi is distributed in the hope that it will be useful, but WITHOUT
10
 
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11
 
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12
 
  Public License for more details.
13
 
 
14
 
  You should have received a copy of the GNU Lesser General Public
15
 
  License along with avahi; if not, write to the Free Software
16
 
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17
 
  USA.
18
 
***/
 
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
19
33
 
20
34
#define _LARGEFILE_SOURCE
21
35
#define _FILE_OFFSET_BITS 64
34
48
#include <avahi-common/error.h>
35
49
 
36
50
//mandos client part
37
 
#include <sys/types.h>          /* socket(), setsockopt(), inet_pton() */
38
 
#include <sys/socket.h>         /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */
39
 
#include <gnutls/gnutls.h>      /* ALL GNUTLS STUFF */
40
 
#include <gnutls/openpgp.h>     /* gnutls with openpgp stuff */
 
51
#include <sys/types.h>          /* socket(), setsockopt(),
 
52
                                   inet_pton() */
 
53
#include <sys/socket.h>         /* socket(), setsockopt(),
 
54
                                   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 */
41
58
 
42
59
#include <unistd.h>             /* close() */
43
60
#include <netinet/in.h>
50
67
#include <errno.h>              /* perror() */
51
68
#include <gpgme.h>
52
69
 
 
70
// getopt long
 
71
#include <getopt.h>
53
72
 
54
73
#ifndef CERT_ROOT
55
74
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
68
87
} encrypted_session;
69
88
 
70
89
 
71
 
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
 
90
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
 
91
                            char **new_packet, const char *homedir){
72
92
  gpgme_data_t dh_crypto, dh_plain;
73
93
  gpgme_ctx_t ctx;
74
94
  gpgme_error_t rc;
75
95
  ssize_t ret;
76
 
  size_t new_packet_capacity = 0;
77
 
  size_t new_packet_length = 0;
 
96
  ssize_t new_packet_capacity = 0;
 
97
  ssize_t new_packet_length = 0;
78
98
  gpgme_engine_info_t engine_info;
79
99
 
80
100
  if (debug){
81
 
    fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
 
101
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
82
102
  }
83
103
  
84
104
  /* Init GPGME */
129
149
    return -1;
130
150
  }
131
151
  
132
 
  /* Decrypt data from the FILE pointer to the plaintext data buffer */
 
152
  /* Decrypt data from the FILE pointer to the plaintext data
 
153
     buffer */
133
154
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
134
155
  if (rc != GPG_ERR_NO_ERROR){
135
156
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
138
159
  }
139
160
 
140
161
  if(debug){
141
 
    fprintf(stderr, "decryption of gpg packet succeeded\n");
 
162
    fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
142
163
  }
143
164
 
144
165
  if (debug){
147
168
    if (result == NULL){
148
169
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
149
170
    } else {
150
 
      fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);
151
 
      fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);
 
171
      fprintf(stderr, "Unsupported algorithm: %s\n",
 
172
              result->unsupported_algorithm);
 
173
      fprintf(stderr, "Wrong key usage: %d\n",
 
174
              result->wrong_key_usage);
152
175
      if(result->file_name != NULL){
153
176
        fprintf(stderr, "File name: %s\n", result->file_name);
154
177
      }
160
183
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
161
184
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
162
185
          fprintf(stderr, "Secret key available: %s\n",
163
 
                  recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
 
186
                  recipient->status == GPG_ERR_NO_SECKEY
 
187
                  ? "No" : "Yes");
164
188
          recipient = recipient->next;
165
189
        }
166
190
      }
176
200
  *new_packet = 0;
177
201
  while(true){
178
202
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
179
 
      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
 
203
      *new_packet = realloc(*new_packet,
 
204
                            (unsigned int)new_packet_capacity
 
205
                            + BUFFER_SIZE);
180
206
      if (*new_packet == NULL){
181
207
        perror("realloc");
182
208
        return -1;
184
210
      new_packet_capacity += BUFFER_SIZE;
185
211
    }
186
212
    
187
 
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
 
213
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
 
214
                          BUFFER_SIZE);
188
215
    /* Print the data, if any */
189
216
    if (ret == 0){
190
 
      /* If password is empty, then a incorrect error will be printed */
191
217
      break;
192
218
    }
193
219
    if(ret < 0){
197
223
    new_packet_length += ret;
198
224
  }
199
225
 
200
 
  if(debug){
201
 
    fprintf(stderr, "decrypted password is: %s\n", *new_packet);
202
 
  }
203
 
 
204
 
   /* Delete the GPGME plaintext data buffer */
 
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
  /*   } */
 
233
  
 
234
  /* Delete the GPGME plaintext data buffer */
205
235
  gpgme_data_release(dh_plain);
206
236
  return new_packet_length;
207
237
}
213
243
  return ret;
214
244
}
215
245
 
216
 
void debuggnutls(int level, const char* string){
 
246
void debuggnutls(__attribute__((unused)) int level,
 
247
                 const char* string){
217
248
  fprintf(stderr, "%s", string);
218
249
}
219
250
 
220
251
int initgnutls(encrypted_session *es){
221
252
  const char *err;
222
253
  int ret;
223
 
 
 
254
  
224
255
  if(debug){
225
 
    fprintf(stderr, "Initializing gnutls\n");
 
256
    fprintf(stderr, "Initializing GnuTLS\n");
226
257
  }
227
 
 
228
258
  
229
259
  if ((ret = gnutls_global_init ())
230
260
      != GNUTLS_E_SUCCESS) {
237
267
    gnutls_global_set_log_function(debuggnutls);
238
268
  }
239
269
  
240
 
 
241
270
  /* openpgp credentials */
242
271
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
243
272
      != GNUTLS_E_SUCCESS) {
244
 
    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
 
273
    fprintf (stderr, "memory error: %s\n",
 
274
             safer_gnutls_strerror(ret));
245
275
    return -1;
246
276
  }
247
 
 
 
277
  
248
278
  if(debug){
249
 
    fprintf(stderr, "Attempting to use openpgp certificate %s"
250
 
            " and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
 
279
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
 
280
            " and keyfile %s as GnuTLS credentials\n", CERTFILE,
 
281
            KEYFILE);
251
282
  }
252
 
 
 
283
  
253
284
  ret = gnutls_certificate_set_openpgp_key_file
254
285
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
255
286
  if (ret != GNUTLS_E_SUCCESS) {
256
287
    fprintf
257
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
 
288
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
 
289
       " '%s')\n",
258
290
       ret, CERTFILE, KEYFILE);
259
291
    fprintf(stdout, "The Error is: %s\n",
260
292
            safer_gnutls_strerror(ret));
261
293
    return -1;
262
294
  }
263
 
 
264
 
  //Gnutls server initialization
 
295
  
 
296
  //GnuTLS server initialization
265
297
  if ((ret = gnutls_dh_params_init (&es->dh_params))
266
298
      != GNUTLS_E_SUCCESS) {
267
299
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
268
300
             safer_gnutls_strerror(ret));
269
301
    return -1;
270
302
  }
271
 
 
 
303
  
272
304
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
273
305
      != GNUTLS_E_SUCCESS) {
274
306
    fprintf (stderr, "Error in prime generation: %s\n",
275
307
             safer_gnutls_strerror(ret));
276
308
    return -1;
277
309
  }
278
 
 
 
310
  
279
311
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
280
 
 
281
 
  // Gnutls session creation
 
312
  
 
313
  // GnuTLS session creation
282
314
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
283
315
      != GNUTLS_E_SUCCESS){
284
 
    fprintf(stderr, "Error in gnutls session initialization: %s\n",
 
316
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
285
317
            safer_gnutls_strerror(ret));
286
318
  }
287
 
 
 
319
  
288
320
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
289
321
      != GNUTLS_E_SUCCESS) {
290
322
    fprintf(stderr, "Syntax error at: %s\n", err);
291
 
    fprintf(stderr, "Gnutls error: %s\n",
 
323
    fprintf(stderr, "GnuTLS error: %s\n",
292
324
            safer_gnutls_strerror(ret));
293
325
    return -1;
294
326
  }
295
 
 
 
327
  
296
328
  if ((ret = gnutls_credentials_set
297
329
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
298
330
      != GNUTLS_E_SUCCESS) {
300
332
            safer_gnutls_strerror(ret));
301
333
    return -1;
302
334
  }
303
 
 
 
335
  
304
336
  /* ignore client certificate if any. */
305
 
  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
 
337
  gnutls_certificate_server_set_request (es->session,
 
338
                                         GNUTLS_CERT_IGNORE);
306
339
  
307
340
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
308
341
  
309
342
  return 0;
310
343
}
311
344
 
312
 
void empty_log(AvahiLogLevel level, const char *txt){}
 
345
void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
346
               __attribute__((unused)) const char *txt){}
313
347
 
314
 
int start_mandos_communcation(char *ip, uint16_t port){
 
348
int start_mandos_communication(char *ip, uint16_t port,
 
349
                               unsigned int if_index){
315
350
  int ret, tcp_sd;
316
351
  struct sockaddr_in6 to;
317
352
  encrypted_session es;
321
356
  size_t buffer_capacity = 0;
322
357
  ssize_t decrypted_buffer_size;
323
358
  int retval = 0;
324
 
  const char interface[] = "eth0";
325
 
 
 
359
  char interface[IF_NAMESIZE];
 
360
  
326
361
  if(debug){
327
362
    fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
328
363
  }
332
367
    perror("socket");
333
368
    return -1;
334
369
  }
335
 
 
 
370
  
 
371
  if(if_indextoname(if_index, interface) == NULL){
 
372
    if(debug){
 
373
      perror("if_indextoname");
 
374
    }
 
375
    return -1;
 
376
  }
 
377
  
336
378
  if(debug){
337
379
    fprintf(stderr, "Binding to interface %s\n", interface);
338
380
  }
339
 
 
 
381
  
340
382
  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
341
 
  if(tcp_sd < 0) {
 
383
  if(ret < 0) {
342
384
    perror("setsockopt bindtodevice");
343
385
    return -1;
344
386
  }
354
396
    fprintf(stderr, "Bad address: %s\n", ip);
355
397
    return -1;
356
398
  }
 
399
  /* Spurious warnings for the next line, see for instance
 
400
     <http://bugs.debian.org/488884> */
357
401
  to.sin6_port = htons(port);
358
 
  to.sin6_scope_id = if_nametoindex(interface);
359
 
 
 
402
  
 
403
  to.sin6_scope_id = (uint32_t)if_index;
 
404
  
360
405
  if(debug){
361
406
    fprintf(stderr, "Connection to: %s\n", ip);
362
407
  }
372
417
    retval = -1;
373
418
    return -1;
374
419
  }
375
 
    
376
 
  
377
 
  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
378
 
 
 
420
  
 
421
  gnutls_transport_set_ptr (es.session,
 
422
                            (gnutls_transport_ptr_t) tcp_sd);
 
423
  
379
424
  if(debug){
380
 
    fprintf(stderr, "Establishing tls session with %s\n", ip);
 
425
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
381
426
  }
382
 
 
383
427
  
384
428
  ret = gnutls_handshake (es.session);
385
429
  
389
433
    retval = -1;
390
434
    goto exit;
391
435
  }
392
 
 
393
 
  //Retrieve gpg packet that contains the wanted password
394
 
 
 
436
  
 
437
  //Retrieve OpenPGP packet that contains the wanted password
 
438
  
395
439
  if(debug){
396
 
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
 
440
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
 
441
            ip);
397
442
  }
398
443
 
399
444
  while(true){
426
471
        }
427
472
        break;
428
473
      default:
429
 
        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
 
474
        fprintf(stderr, "Unknown error while reading data from"
 
475
                " encrypted session with mandos server\n");
430
476
        retval = -1;
431
477
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
432
478
        goto exit;
433
479
      }
434
480
    } else {
435
 
      buffer_length += ret;
 
481
      buffer_length += (size_t) ret;
436
482
    }
437
483
  }
438
484
  
439
485
  if (buffer_length > 0){
440
 
    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
441
 
      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
 
486
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
487
                                               buffer_length,
 
488
                                               &decrypted_buffer,
 
489
                                               CERT_ROOT);
 
490
    if (decrypted_buffer_size >= 0){
 
491
      while(decrypted_buffer_size > 0){
 
492
        ret = fwrite (decrypted_buffer, 1, (size_t)decrypted_buffer_size,
 
493
                      stdout);
 
494
        if(ret == 0 and ferror(stdout)){
 
495
          if(debug){
 
496
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
497
                    strerror(errno));
 
498
          }
 
499
          retval = -1;
 
500
          break;
 
501
        }
 
502
        decrypted_buffer += ret;
 
503
        decrypted_buffer_size -= ret;
 
504
      }
442
505
      free(decrypted_buffer);
443
506
    } else {
444
507
      retval = -1;
448
511
  //shutdown procedure
449
512
 
450
513
  if(debug){
451
 
    fprintf(stderr, "Closing tls session\n");
 
514
    fprintf(stderr, "Closing TLS session\n");
452
515
  }
453
516
 
454
517
  free(buffer);
475
538
    const char *host_name,
476
539
    const AvahiAddress *address,
477
540
    uint16_t port,
478
 
    AvahiStringList *txt,
479
 
    AvahiLookupResultFlags flags,
 
541
    AVAHI_GCC_UNUSED AvahiStringList *txt,
 
542
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
480
543
    AVAHI_GCC_UNUSED void* userdata) {
481
544
    
482
 
    assert(r);
483
 
 
484
 
    /* Called whenever a service has been resolved successfully or timed out */
485
 
 
486
 
    switch (event) {
487
 
        case AVAHI_RESOLVER_FAILURE:
488
 
            fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));
489
 
            break;
490
 
 
491
 
        case AVAHI_RESOLVER_FOUND: {
492
 
          char ip[AVAHI_ADDRESS_STR_MAX];
493
 
            avahi_address_snprint(ip, sizeof(ip), address);
494
 
            if(debug){
495
 
              fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
496
 
            }
497
 
            int ret = start_mandos_communcation(ip, port);
498
 
            if (ret == 0){
499
 
              exit(EXIT_SUCCESS);
500
 
            } else {
501
 
              exit(EXIT_FAILURE);
502
 
            }
503
 
        }
 
545
  assert(r);
 
546
 
 
547
  /* Called whenever a service has been resolved successfully or
 
548
     timed out */
 
549
 
 
550
  switch (event) {
 
551
  default:
 
552
  case AVAHI_RESOLVER_FAILURE:
 
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)));
 
556
    break;
 
557
      
 
558
  case AVAHI_RESOLVER_FOUND:
 
559
    {
 
560
      char ip[AVAHI_ADDRESS_STR_MAX];
 
561
      avahi_address_snprint(ip, sizeof(ip), address);
 
562
      if(debug){
 
563
        fprintf(stderr, "Mandos server found on %s (%s) on port %d\n",
 
564
                host_name, ip, port);
 
565
      }
 
566
      int ret = start_mandos_communication(ip, port,
 
567
                                           (unsigned int)
 
568
                                           interface);
 
569
      if (ret == 0){
 
570
        exit(EXIT_SUCCESS);
 
571
      } else {
 
572
        exit(EXIT_FAILURE);
 
573
      }
504
574
    }
505
 
    avahi_s_service_resolver_free(r);
 
575
  }
 
576
  avahi_s_service_resolver_free(r);
506
577
}
507
578
 
508
579
static void browse_callback(
519
590
    AvahiServer *s = userdata;
520
591
    assert(b);
521
592
 
522
 
    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
 
593
    /* Called whenever a new services becomes available on the LAN or
 
594
       is removed from the LAN */
523
595
 
524
596
    switch (event) {
525
 
 
526
 
        case AVAHI_BROWSER_FAILURE:
527
 
            
528
 
            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
529
 
            avahi_simple_poll_quit(simple_poll);
530
 
            return;
531
 
 
532
 
        case AVAHI_BROWSER_NEW:
533
 
            /* We ignore the returned resolver object. In the callback
534
 
               function we free it. If the server is terminated before
535
 
               the callback function is called the server will free
536
 
               the resolver for us. */
537
 
            
538
 
            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
539
 
                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
540
 
            
541
 
            break;
542
 
 
543
 
        case AVAHI_BROWSER_REMOVE:
544
 
            break;
545
 
 
546
 
        case AVAHI_BROWSER_ALL_FOR_NOW:
547
 
        case AVAHI_BROWSER_CACHE_EXHAUSTED:
548
 
            break;
 
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;
549
625
    }
550
626
}
551
627
 
552
628
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
553
629
    AvahiServerConfig config;
554
630
    AvahiSServiceBrowser *sb = NULL;
555
 
    const char db[] = "--debug";
556
631
    int error;
557
 
    int ret = 1;
 
632
    int ret;
558
633
    int returncode = EXIT_SUCCESS;
559
 
    char *basename = rindex(argv[0], '/');
560
 
    if(basename == NULL){
561
 
      basename = argv[0];
562
 
    } else {
563
 
      basename++;
564
 
    }
565
 
    
566
 
    char *program_name = malloc(strlen(basename) + sizeof(db));
567
 
 
568
 
    if (program_name == NULL){
569
 
      perror("argv[0]");
570
 
      return EXIT_FAILURE;
571
 
    }
572
 
    
573
 
    program_name[0] = '\0';
574
 
    
575
 
    for (int i = 1; i < argc; i++){
576
 
      if (not strncmp(argv[i], db, 5)){
577
 
          strcat(strcat(strcat(program_name, db ), "="), basename);
578
 
          if(not strcmp(argv[i], db) or not strcmp(argv[i], program_name)){
579
 
            debug = true;
580
 
          }
581
 
        }
582
 
    }
583
 
    free(program_name);
584
 
 
 
634
    const char *interface = "eth0";
 
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
      }
 
659
    }
 
660
    
585
661
    if (not debug){
586
662
      avahi_set_log_function(empty_log);
587
663
    }
588
664
    
589
665
    /* Initialize the psuedo-RNG */
590
 
    srand(time(NULL));
 
666
    srand((unsigned int) time(NULL));
591
667
 
592
668
    /* Allocate main loop object */
593
669
    if (!(simple_poll = avahi_simple_poll_new())) {
604
680
    config.publish_domain = 0;
605
681
 
606
682
    /* Allocate a new server */
607
 
    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
 
683
    server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
684
                              &config, NULL, NULL, &error);
608
685
 
609
686
    /* Free the configuration data */
610
687
    avahi_server_config_free(&config);
611
688
 
612
689
    /* Check if creating the server object succeeded */
613
690
    if (!server) {
614
 
        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
 
691
        fprintf(stderr, "Failed to create server: %s\n",
 
692
                avahi_strerror(error));
615
693
        returncode = EXIT_FAILURE;
616
694
        goto exit;
617
695
    }
618
696
    
619
697
    /* Create the service browser */
620
 
    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
621
 
        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
 
698
    sb = avahi_s_service_browser_new(server,
 
699
                                     (AvahiIfIndex)
 
700
                                     if_nametoindex(interface),
 
701
                                     AVAHI_PROTO_INET6,
 
702
                                     "_mandos._tcp", NULL, 0,
 
703
                                     browse_callback, server);
 
704
    if (!sb) {
 
705
        fprintf(stderr, "Failed to create service browser: %s\n",
 
706
                avahi_strerror(avahi_server_errno(server)));
622
707
        returncode = EXIT_FAILURE;
623
708
        goto exit;
624
709
    }
631
716
    
632
717
    avahi_simple_poll_loop(simple_poll);
633
718
    
634
 
exit:
 
719
 exit:
635
720
 
636
721
    if (debug){
637
722
      fprintf(stderr, "%s exiting\n", argv[0]);
647
732
    if (simple_poll)
648
733
        avahi_simple_poll_free(simple_poll);
649
734
 
650
 
    return ret;
 
735
    return returncode;
651
736
}