/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-20 06:33:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080720063348-jscgy5p0itrgvlo8
* mandos-clients.conf ([foo]): Uncommented.
  ([foo]/secret): New.
  ([foo]/secfile): Commented out.
  ([foo]/checker): Changed to "fping -q -- %%(fqdn)s".
  ([foo]/timeout): New.

* server.py: New modeline for Python and Emacs.  Set a logging format.
  (Client.__init__): Bug fix: Choose either the value from the options
                     object or pass the argument through string_to_delta
                     for both "timeout" and "interval".
  (Client.checker_callback): Bug fix: Do not log spurious "Checker for
                             <foo> failed" messages.
  (Client.start_checker): Moved "Starting checker" log message down to
                          just before actually starting the subprocess.
                          Do not redirect the subprocesses' stdout to a
                          pipe.
  (peer_certificate, fingerprint): Added docstrings.
  (entry_group_state_changed): Call "killme()" instead of
                               "main_loop.quit()".
  (daemon, killme): New functions.
  (exitstatus, main_loop_started): New global variables.
  (__main__): Removed the "--cert", "--key", "--ca", and "--crl"
              options.  Removed the sleep command from the default
              checker.  Add a console logger in debug mode.  Call
              "killme()" instead of "main_loop.quit()" when there are no
              more clients.  Call "daemon()" if not in debug mode.
              Register "cleanup()" to run at exit.  Ignore some
              signals.  Catch DBusException to detect another running
              server and exit cleanly.  Exit with "exitstatus".
  (cleanup): New function.

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