/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-01 06:33:15 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080801063315-4k33q3ek28hjc3tu
* plugins.d/plugbasedclient.c: Update include file comments.
  (struct process.disable): Renamed to "disabled".  All users changed.
  (addarguments): Renamed to "addargument".  All callers changed.
  (doc, args_doc): Removed.
  (main): Changed default "plugindir" to
          "/conf/conf.d/mandos/plugins.d".  Renamed "rfds_orig" to
           "rfds_all"; all users changed.  New "debug" and
           "exitstatus" variables.  New "--debug" option.  Removed
           unnecessary ".flags = 0" from all options.  Changed so that
           "--disable-plugin" only takes one plugin.  Check for
           non-existence of ":" in argument to "--options-for".  Added
           some debugging outputs.  Set the FD_CLOEXEC flag on the
           directory FD.  More capable code for dealing with
           disallowed plugin file name prefixes and suffixes.  Bug
           fix: check for some malloc failures.  Moved allocating the
           "struct process *new_process" to after the fork.  Do
           _exit() instead of exit() in the child.

* plugins.d/mandosclient.c: Updated contact information.

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
 
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
 */
19
30
 
 
31
/* Needed by GPGME, specifically gpgme_data_seek() */
20
32
#define _LARGEFILE_SOURCE
21
33
#define _FILE_OFFSET_BITS 64
22
34
 
34
46
#include <avahi-common/error.h>
35
47
 
36
48
//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 */
 
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 */
41
54
 
42
55
#include <unistd.h>             /* close() */
43
56
#include <netinet/in.h>
50
63
#include <errno.h>              /* perror() */
51
64
#include <gpgme.h>
52
65
 
 
66
// getopt long
 
67
#include <getopt.h>
53
68
 
54
 
#ifndef CERT_ROOT
55
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
56
 
#endif
57
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
58
 
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
59
69
#define BUFFER_SIZE 256
60
70
#define DH_BITS 1024
61
71
 
62
 
bool debug;
 
72
const char *certdir = "/conf/conf.d/cryptkeyreq/";
 
73
const char *certfile = "openpgp-client.txt";
 
74
const char *certkey = "openpgp-client-key.txt";
 
75
 
 
76
bool debug = false;
63
77
 
64
78
typedef struct {
65
79
  gnutls_session_t session;
68
82
} encrypted_session;
69
83
 
70
84
 
71
 
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
 
85
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
 
86
                            char **new_packet, const char *homedir){
72
87
  gpgme_data_t dh_crypto, dh_plain;
73
88
  gpgme_ctx_t ctx;
74
89
  gpgme_error_t rc;
75
90
  ssize_t ret;
76
 
  size_t new_packet_capacity = 0;
77
 
  size_t new_packet_length = 0;
 
91
  ssize_t new_packet_capacity = 0;
 
92
  ssize_t new_packet_length = 0;
78
93
  gpgme_engine_info_t engine_info;
79
94
 
80
95
  if (debug){
81
 
    fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
 
96
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
82
97
  }
83
98
  
84
99
  /* Init GPGME */
85
100
  gpgme_check_version(NULL);
86
 
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
101
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
102
  if (rc != GPG_ERR_NO_ERROR){
 
103
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
104
            gpgme_strsource(rc), gpgme_strerror(rc));
 
105
    return -1;
 
106
  }
87
107
  
88
108
  /* Set GPGME home directory */
89
109
  rc = gpgme_get_engine_info (&engine_info);
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
      }
171
195
  gpgme_data_release(dh_crypto);
172
196
  
173
197
  /* Seek back to the beginning of the GPGME plaintext data buffer */
174
 
  gpgme_data_seek(dh_plain, 0, SEEK_SET);
175
 
 
 
198
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
199
    perror("pgpme_data_seek");
 
200
  }
 
201
  
176
202
  *new_packet = 0;
177
203
  while(true){
178
204
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
179
 
      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
 
205
      *new_packet = realloc(*new_packet,
 
206
                            (unsigned int)new_packet_capacity
 
207
                            + BUFFER_SIZE);
180
208
      if (*new_packet == NULL){
181
209
        perror("realloc");
182
210
        return -1;
184
212
      new_packet_capacity += BUFFER_SIZE;
185
213
    }
186
214
    
187
 
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
 
215
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
 
216
                          BUFFER_SIZE);
188
217
    /* Print the data, if any */
189
218
    if (ret == 0){
190
 
      /* If password is empty, then a incorrect error will be printed */
191
219
      break;
192
220
    }
193
221
    if(ret < 0){
197
225
    new_packet_length += ret;
198
226
  }
199
227
 
200
 
  if(debug){
201
 
    fprintf(stderr, "decrypted password is: %s\n", *new_packet);
202
 
  }
203
 
 
204
 
   /* Delete the GPGME plaintext data buffer */
 
228
  /* FIXME: check characters before printing to screen so to not print
 
229
     terminal control characters */
 
230
  /*   if(debug){ */
 
231
  /*     fprintf(stderr, "decrypted password is: "); */
 
232
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
 
233
  /*     fprintf(stderr, "\n"); */
 
234
  /*   } */
 
235
  
 
236
  /* Delete the GPGME plaintext data buffer */
205
237
  gpgme_data_release(dh_plain);
206
238
  return new_packet_length;
207
239
}
213
245
  return ret;
214
246
}
215
247
 
216
 
void debuggnutls(int level, const char* string){
 
248
void debuggnutls(__attribute__((unused)) int level,
 
249
                 const char* string){
217
250
  fprintf(stderr, "%s", string);
218
251
}
219
252
 
220
253
int initgnutls(encrypted_session *es){
221
254
  const char *err;
222
255
  int ret;
223
 
 
 
256
  
224
257
  if(debug){
225
 
    fprintf(stderr, "Initializing gnutls\n");
 
258
    fprintf(stderr, "Initializing GnuTLS\n");
226
259
  }
227
260
 
228
 
  
229
261
  if ((ret = gnutls_global_init ())
230
262
      != GNUTLS_E_SUCCESS) {
231
263
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
237
269
    gnutls_global_set_log_function(debuggnutls);
238
270
  }
239
271
  
240
 
 
241
272
  /* openpgp credentials */
242
273
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
243
274
      != GNUTLS_E_SUCCESS) {
244
 
    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
 
275
    fprintf (stderr, "memory error: %s\n",
 
276
             safer_gnutls_strerror(ret));
245
277
    return -1;
246
278
  }
247
 
 
 
279
  
248
280
  if(debug){
249
 
    fprintf(stderr, "Attempting to use openpgp certificate %s"
250
 
            " and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
 
281
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
 
282
            " and keyfile %s as GnuTLS credentials\n", certfile,
 
283
            certkey);
251
284
  }
252
 
 
 
285
  
253
286
  ret = gnutls_certificate_set_openpgp_key_file
254
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
 
287
    (es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
255
288
  if (ret != GNUTLS_E_SUCCESS) {
256
289
    fprintf
257
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
258
 
       ret, CERTFILE, KEYFILE);
 
290
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
 
291
       " '%s')\n",
 
292
       ret, certfile, certkey);
259
293
    fprintf(stdout, "The Error is: %s\n",
260
294
            safer_gnutls_strerror(ret));
261
295
    return -1;
262
296
  }
263
 
 
264
 
  //Gnutls server initialization
 
297
  
 
298
  //GnuTLS server initialization
265
299
  if ((ret = gnutls_dh_params_init (&es->dh_params))
266
300
      != GNUTLS_E_SUCCESS) {
267
301
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
268
302
             safer_gnutls_strerror(ret));
269
303
    return -1;
270
304
  }
271
 
 
 
305
  
272
306
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
273
307
      != GNUTLS_E_SUCCESS) {
274
308
    fprintf (stderr, "Error in prime generation: %s\n",
275
309
             safer_gnutls_strerror(ret));
276
310
    return -1;
277
311
  }
278
 
 
 
312
  
279
313
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
280
 
 
281
 
  // Gnutls session creation
 
314
  
 
315
  // GnuTLS session creation
282
316
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
283
317
      != GNUTLS_E_SUCCESS){
284
 
    fprintf(stderr, "Error in gnutls session initialization: %s\n",
 
318
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
285
319
            safer_gnutls_strerror(ret));
286
320
  }
287
 
 
 
321
  
288
322
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
289
323
      != GNUTLS_E_SUCCESS) {
290
324
    fprintf(stderr, "Syntax error at: %s\n", err);
291
 
    fprintf(stderr, "Gnutls error: %s\n",
 
325
    fprintf(stderr, "GnuTLS error: %s\n",
292
326
            safer_gnutls_strerror(ret));
293
327
    return -1;
294
328
  }
295
 
 
 
329
  
296
330
  if ((ret = gnutls_credentials_set
297
331
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
298
332
      != GNUTLS_E_SUCCESS) {
300
334
            safer_gnutls_strerror(ret));
301
335
    return -1;
302
336
  }
303
 
 
 
337
  
304
338
  /* ignore client certificate if any. */
305
 
  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
 
339
  gnutls_certificate_server_set_request (es->session,
 
340
                                         GNUTLS_CERT_IGNORE);
306
341
  
307
342
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
308
343
  
309
344
  return 0;
310
345
}
311
346
 
312
 
void empty_log(AvahiLogLevel level, const char *txt){}
 
347
void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
348
               __attribute__((unused)) const char *txt){}
313
349
 
314
 
int start_mandos_communcation(char *ip, uint16_t port){
 
350
int start_mandos_communication(const char *ip, uint16_t port,
 
351
                               AvahiIfIndex if_index){
315
352
  int ret, tcp_sd;
316
353
  struct sockaddr_in6 to;
317
 
  struct in6_addr ip_addr;
318
354
  encrypted_session es;
319
355
  char *buffer = NULL;
320
356
  char *decrypted_buffer;
321
357
  size_t buffer_length = 0;
322
358
  size_t buffer_capacity = 0;
323
359
  ssize_t decrypted_buffer_size;
 
360
  size_t written = 0;
324
361
  int retval = 0;
325
 
  const char interface[] = "eth0";
326
 
 
 
362
  char interface[IF_NAMESIZE];
 
363
  
327
364
  if(debug){
328
 
    fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
 
365
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
 
366
            ip, port);
329
367
  }
330
368
  
331
369
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
333
371
    perror("socket");
334
372
    return -1;
335
373
  }
336
 
 
 
374
  
 
375
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
376
    if(debug){
 
377
      perror("if_indextoname");
 
378
    }
 
379
    return -1;
 
380
  }
 
381
  
337
382
  if(debug){
338
383
    fprintf(stderr, "Binding to interface %s\n", interface);
339
384
  }
340
 
 
341
 
  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
342
 
  if(tcp_sd < 0) {
343
 
    perror("setsockopt bindtodevice");
344
 
    return -1;
345
 
  }
346
385
  
347
 
  memset(&to,0,sizeof(to));
 
386
  memset(&to,0,sizeof(to));     /* Spurious warning */
348
387
  to.sin6_family = AF_INET6;
349
 
  ret = inet_pton(AF_INET6, ip, &ip_addr);
 
388
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
350
389
  if (ret < 0 ){
351
390
    perror("inet_pton");
352
391
    return -1;
355
394
    fprintf(stderr, "Bad address: %s\n", ip);
356
395
    return -1;
357
396
  }
358
 
  to.sin6_port = htons(port);
359
 
  to.sin6_scope_id = if_nametoindex(interface);
360
 
 
 
397
  to.sin6_port = htons(port);   /* Spurious warning */
 
398
  
 
399
  to.sin6_scope_id = (uint32_t)if_index;
 
400
  
361
401
  if(debug){
362
 
    fprintf(stderr, "Connection to: %s\n", ip);
 
402
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
 
403
/*     char addrstr[INET6_ADDRSTRLEN]; */
 
404
/*     if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr, */
 
405
/*               sizeof(addrstr)) == NULL){ */
 
406
/*       perror("inet_ntop"); */
 
407
/*     } else { */
 
408
/*       fprintf(stderr, "Really connecting to: %s, port %d\n", */
 
409
/*            addrstr, ntohs(to.sin6_port)); */
 
410
/*     } */
363
411
  }
364
412
  
365
413
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
373
421
    retval = -1;
374
422
    return -1;
375
423
  }
376
 
    
377
 
  
378
 
  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
379
 
 
 
424
  
 
425
  gnutls_transport_set_ptr (es.session,
 
426
                            (gnutls_transport_ptr_t) tcp_sd);
 
427
  
380
428
  if(debug){
381
 
    fprintf(stderr, "Establishing tls session with %s\n", ip);
 
429
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
382
430
  }
383
 
 
384
431
  
385
432
  ret = gnutls_handshake (es.session);
386
433
  
387
434
  if (ret != GNUTLS_E_SUCCESS){
388
 
    fprintf(stderr, "\n*** Handshake failed ***\n");
389
 
    gnutls_perror (ret);
 
435
    if(debug){
 
436
      fprintf(stderr, "\n*** Handshake failed ***\n");
 
437
      gnutls_perror (ret);
 
438
    }
390
439
    retval = -1;
391
440
    goto exit;
392
441
  }
393
 
 
394
 
  //Retrieve gpg packet that contains the wanted password
395
 
 
 
442
  
 
443
  //Retrieve OpenPGP packet that contains the wanted password
 
444
  
396
445
  if(debug){
397
 
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
 
446
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
 
447
            ip);
398
448
  }
399
449
 
400
450
  while(true){
427
477
        }
428
478
        break;
429
479
      default:
430
 
        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
 
480
        fprintf(stderr, "Unknown error while reading data from"
 
481
                " encrypted session with mandos server\n");
431
482
        retval = -1;
432
483
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
433
484
        goto exit;
434
485
      }
435
486
    } else {
436
 
      buffer_length += ret;
 
487
      buffer_length += (size_t) ret;
437
488
    }
438
489
  }
439
490
  
440
491
  if (buffer_length > 0){
441
 
    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
442
 
      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
 
492
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
493
                                               buffer_length,
 
494
                                               &decrypted_buffer,
 
495
                                               certdir);
 
496
    if (decrypted_buffer_size >= 0){
 
497
      while(written < (size_t) decrypted_buffer_size){
 
498
        ret = (int)fwrite (decrypted_buffer + written, 1,
 
499
                           (size_t)decrypted_buffer_size - written,
 
500
                           stdout);
 
501
        if(ret == 0 and ferror(stdout)){
 
502
          if(debug){
 
503
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
504
                    strerror(errno));
 
505
          }
 
506
          retval = -1;
 
507
          break;
 
508
        }
 
509
        written += (size_t)ret;
 
510
      }
443
511
      free(decrypted_buffer);
444
512
    } else {
445
513
      retval = -1;
449
517
  //shutdown procedure
450
518
 
451
519
  if(debug){
452
 
    fprintf(stderr, "Closing tls session\n");
 
520
    fprintf(stderr, "Closing TLS session\n");
453
521
  }
454
522
 
455
523
  free(buffer);
467
535
 
468
536
static void resolve_callback(
469
537
    AvahiSServiceResolver *r,
470
 
    AVAHI_GCC_UNUSED AvahiIfIndex interface,
 
538
    AvahiIfIndex interface,
471
539
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
472
540
    AvahiResolverEvent event,
473
541
    const char *name,
476
544
    const char *host_name,
477
545
    const AvahiAddress *address,
478
546
    uint16_t port,
479
 
    AvahiStringList *txt,
480
 
    AvahiLookupResultFlags flags,
 
547
    AVAHI_GCC_UNUSED AvahiStringList *txt,
 
548
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
481
549
    AVAHI_GCC_UNUSED void* userdata) {
482
550
    
483
 
    assert(r);
484
 
 
485
 
    /* Called whenever a service has been resolved successfully or timed out */
486
 
 
487
 
    switch (event) {
488
 
        case AVAHI_RESOLVER_FAILURE:
489
 
            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)));
490
 
            break;
491
 
 
492
 
        case AVAHI_RESOLVER_FOUND: {
493
 
          char ip[AVAHI_ADDRESS_STR_MAX];
494
 
            avahi_address_snprint(ip, sizeof(ip), address);
495
 
            if(debug){
496
 
              fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
497
 
            }
498
 
            int ret = start_mandos_communcation(ip, port);
499
 
            if (ret == 0){
500
 
              exit(EXIT_SUCCESS);
501
 
            } else {
502
 
              exit(EXIT_FAILURE);
503
 
            }
504
 
        }
 
551
  assert(r);                    /* Spurious warning */
 
552
  
 
553
  /* Called whenever a service has been resolved successfully or
 
554
     timed out */
 
555
  
 
556
  switch (event) {
 
557
  default:
 
558
  case AVAHI_RESOLVER_FAILURE:
 
559
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
 
560
            " type '%s' in domain '%s': %s\n", name, type, domain,
 
561
            avahi_strerror(avahi_server_errno(server)));
 
562
    break;
 
563
    
 
564
  case AVAHI_RESOLVER_FOUND:
 
565
    {
 
566
      char ip[AVAHI_ADDRESS_STR_MAX];
 
567
      avahi_address_snprint(ip, sizeof(ip), address);
 
568
      if(debug){
 
569
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
 
570
                " port %d\n", name, host_name, ip, port);
 
571
      }
 
572
      int ret = start_mandos_communication(ip, port, interface);
 
573
      if (ret == 0){
 
574
        exit(EXIT_SUCCESS);
 
575
      }
505
576
    }
506
 
    avahi_s_service_resolver_free(r);
 
577
  }
 
578
  avahi_s_service_resolver_free(r);
507
579
}
508
580
 
509
581
static void browse_callback(
518
590
    void* userdata) {
519
591
    
520
592
    AvahiServer *s = userdata;
521
 
    assert(b);
522
 
 
523
 
    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
524
 
 
 
593
    assert(b);                  /* Spurious warning */
 
594
    
 
595
    /* Called whenever a new services becomes available on the LAN or
 
596
       is removed from the LAN */
 
597
    
525
598
    switch (event) {
526
 
 
527
 
        case AVAHI_BROWSER_FAILURE:
528
 
            
529
 
            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
530
 
            avahi_simple_poll_quit(simple_poll);
531
 
            return;
532
 
 
533
 
        case AVAHI_BROWSER_NEW:
534
 
            /* We ignore the returned resolver object. In the callback
535
 
               function we free it. If the server is terminated before
536
 
               the callback function is called the server will free
537
 
               the resolver for us. */
538
 
            
539
 
            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
540
 
                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
541
 
            
542
 
            break;
543
 
 
544
 
        case AVAHI_BROWSER_REMOVE:
545
 
            break;
546
 
 
547
 
        case AVAHI_BROWSER_ALL_FOR_NOW:
548
 
        case AVAHI_BROWSER_CACHE_EXHAUSTED:
549
 
            break;
 
599
    default:
 
600
    case AVAHI_BROWSER_FAILURE:
 
601
      
 
602
      fprintf(stderr, "(Browser) %s\n",
 
603
              avahi_strerror(avahi_server_errno(server)));
 
604
      avahi_simple_poll_quit(simple_poll);
 
605
      return;
 
606
      
 
607
    case AVAHI_BROWSER_NEW:
 
608
      /* We ignore the returned resolver object. In the callback
 
609
         function we free it. If the server is terminated before
 
610
         the callback function is called the server will free
 
611
         the resolver for us. */
 
612
      
 
613
      if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
 
614
                                         type, domain,
 
615
                                         AVAHI_PROTO_INET6, 0,
 
616
                                         resolve_callback, s)))
 
617
        fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
 
618
                avahi_strerror(avahi_server_errno(s)));
 
619
      break;
 
620
      
 
621
    case AVAHI_BROWSER_REMOVE:
 
622
      break;
 
623
      
 
624
    case AVAHI_BROWSER_ALL_FOR_NOW:
 
625
    case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
626
      break;
550
627
    }
551
628
}
552
629
 
 
630
/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */
 
631
const char *combinepath(const char *first, const char *second){
 
632
  char *tmp;
 
633
  tmp = malloc(strlen(first) + strlen(second) + 2);
 
634
  if (tmp == NULL){
 
635
    perror("malloc");
 
636
    return NULL;
 
637
  }
 
638
  strcpy(tmp, first);
 
639
  if (first[0] != '\0' and first[strlen(first) - 1] != '/'){
 
640
    strcat(tmp, "/");
 
641
  }
 
642
  strcat(tmp, second);
 
643
  return tmp;
 
644
}
 
645
 
 
646
 
553
647
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
554
648
    AvahiServerConfig config;
555
649
    AvahiSServiceBrowser *sb = NULL;
556
 
    const char db[] = "--debug";
557
650
    int error;
558
 
    int ret = 1;
 
651
    int ret;
559
652
    int returncode = EXIT_SUCCESS;
560
 
    char *basename = rindex(argv[0], '/');
561
 
    if(basename == NULL){
562
 
      basename = argv[0];
563
 
    } else {
564
 
      basename++;
565
 
    }
566
 
    
567
 
    char *program_name = malloc(strlen(basename) + sizeof(db));
568
 
 
569
 
    if (program_name == NULL){
570
 
      perror("argv[0]");
571
 
      return EXIT_FAILURE;
572
 
    }
573
 
    
574
 
    program_name[0] = '\0';
575
 
    
576
 
    for (int i = 1; i < argc; i++){
577
 
      if (not strncmp(argv[i], db, 5)){
578
 
          strcat(strcat(strcat(program_name, db ), "="), basename);
579
 
          if(not strcmp(argv[i], db) or not strcmp(argv[i], program_name)){
580
 
            debug = true;
581
 
          }
582
 
        }
583
 
    }
584
 
    free(program_name);
585
 
 
 
653
    const char *interface = NULL;
 
654
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
655
    char *connect_to = NULL;
 
656
    
 
657
    while (true){
 
658
      static struct option long_options[] = {
 
659
        {"debug", no_argument, (int *)&debug, 1},
 
660
        {"connect", required_argument, 0, 'C'},
 
661
        {"interface", required_argument, 0, 'i'},
 
662
        {"certdir", required_argument, 0, 'd'},
 
663
        {"certkey", required_argument, 0, 'c'},
 
664
        {"certfile", required_argument, 0, 'k'},
 
665
        {0, 0, 0, 0} };
 
666
      
 
667
      int option_index = 0;
 
668
      ret = getopt_long (argc, argv, "i:", long_options,
 
669
                         &option_index);
 
670
      
 
671
      if (ret == -1){
 
672
        break;
 
673
      }
 
674
      
 
675
      switch(ret){
 
676
      case 0:
 
677
        break;
 
678
      case 'i':
 
679
        interface = optarg;
 
680
        break;
 
681
      case 'C':
 
682
        connect_to = optarg;
 
683
        break;
 
684
      case 'd':
 
685
        certdir = optarg;
 
686
        break;
 
687
      case 'c':
 
688
        certfile = optarg;
 
689
        break;
 
690
      case 'k':
 
691
        certkey = optarg;
 
692
        break;
 
693
      default:
 
694
        exit(EXIT_FAILURE);
 
695
      }
 
696
    }
 
697
 
 
698
    certfile = combinepath(certdir, certfile);
 
699
    if (certfile == NULL){
 
700
      goto exit;
 
701
    }
 
702
    
 
703
    if(interface != NULL){
 
704
      if_index = (AvahiIfIndex) if_nametoindex(interface);
 
705
      if(if_index == 0){
 
706
        fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
707
        exit(EXIT_FAILURE);
 
708
      }
 
709
    }
 
710
    
 
711
    if(connect_to != NULL){
 
712
      /* Connect directly, do not use Zeroconf */
 
713
      /* (Mainly meant for debugging) */
 
714
      char *address = strrchr(connect_to, ':');
 
715
      if(address == NULL){
 
716
        fprintf(stderr, "No colon in address\n");
 
717
        exit(EXIT_FAILURE);
 
718
      }
 
719
      errno = 0;
 
720
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
 
721
      if(errno){
 
722
        perror("Bad port number");
 
723
        exit(EXIT_FAILURE);
 
724
      }
 
725
      *address = '\0';
 
726
      address = connect_to;
 
727
      ret = start_mandos_communication(address, port, if_index);
 
728
      if(ret < 0){
 
729
        exit(EXIT_FAILURE);
 
730
      } else {
 
731
        exit(EXIT_SUCCESS);
 
732
      }
 
733
    }
 
734
    
 
735
    certkey = combinepath(certdir, certkey);
 
736
    if (certkey == NULL){
 
737
      goto exit;
 
738
    }
 
739
    
586
740
    if (not debug){
587
741
      avahi_set_log_function(empty_log);
588
742
    }
589
743
    
590
744
    /* Initialize the psuedo-RNG */
591
 
    srand(time(NULL));
 
745
    srand((unsigned int) time(NULL));
592
746
 
593
747
    /* Allocate main loop object */
594
748
    if (!(simple_poll = avahi_simple_poll_new())) {
605
759
    config.publish_domain = 0;
606
760
 
607
761
    /* Allocate a new server */
608
 
    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
 
762
    server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
763
                              &config, NULL, NULL, &error);
609
764
 
610
765
    /* Free the configuration data */
611
766
    avahi_server_config_free(&config);
612
767
 
613
768
    /* Check if creating the server object succeeded */
614
769
    if (!server) {
615
 
        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
 
770
        fprintf(stderr, "Failed to create server: %s\n",
 
771
                avahi_strerror(error));
616
772
        returncode = EXIT_FAILURE;
617
773
        goto exit;
618
774
    }
619
775
    
620
776
    /* Create the service browser */
621
 
    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
622
 
        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
 
777
    sb = avahi_s_service_browser_new(server, if_index,
 
778
                                     AVAHI_PROTO_INET6,
 
779
                                     "_mandos._tcp", NULL, 0,
 
780
                                     browse_callback, server);
 
781
    if (!sb) {
 
782
        fprintf(stderr, "Failed to create service browser: %s\n",
 
783
                avahi_strerror(avahi_server_errno(server)));
623
784
        returncode = EXIT_FAILURE;
624
785
        goto exit;
625
786
    }
632
793
    
633
794
    avahi_simple_poll_loop(simple_poll);
634
795
    
635
 
exit:
 
796
 exit:
636
797
 
637
798
    if (debug){
638
799
      fprintf(stderr, "%s exiting\n", argv[0]);
647
808
 
648
809
    if (simple_poll)
649
810
        avahi_simple_poll_free(simple_poll);
650
 
 
651
 
    return ret;
 
811
    free(certfile);
 
812
    free(certkey);
 
813
    
 
814
    return returncode;
652
815
}