/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/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2009-09-05 17:20:46 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090905172046-s92efz3m1j4c1sti
* plugins-runner.c (main): Bug fix: Close config file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Mandos-client - get and decrypt data from a Mandos server
 
4
 *
 
5
 * This program is partly derived from an example program for an Avahi
 
6
 * service browser, downloaded from
 
7
 * <http://avahi.org/browser/examples/core-browse-services.c>.  This
 
8
 * includes the following functions: "resolve_callback",
 
9
 * "browse_callback", and parts of "main".
 
10
 * 
 
11
 * Everything else is
 
12
 * Copyright © 2008,2009 Teddy Hogeborn
 
13
 * Copyright © 2008,2009 Björn Påhlsson
 
14
 * 
 
15
 * This program is free software: you can redistribute it and/or
 
16
 * modify it under the terms of the GNU General Public License as
 
17
 * published by the Free Software Foundation, either version 3 of the
 
18
 * License, or (at your option) any later version.
 
19
 * 
 
20
 * This program is distributed in the hope that it will be useful, but
 
21
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
22
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
23
 * General Public License for more details.
 
24
 * 
 
25
 * You should have received a copy of the GNU General Public License
 
26
 * along with this program.  If not, see
 
27
 * <http://www.gnu.org/licenses/>.
 
28
 * 
 
29
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
30
 */
 
31
 
 
32
/* Needed by GPGME, specifically gpgme_data_seek() */
 
33
#ifndef _LARGEFILE_SOURCE
 
34
#define _LARGEFILE_SOURCE
 
35
#endif
 
36
#ifndef _FILE_OFFSET_BITS
 
37
#define _FILE_OFFSET_BITS 64
 
38
#endif
 
39
 
 
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
 
41
 
 
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
 
43
                                   stdout, ferror(), remove() */
 
44
#include <stdint.h>             /* uint16_t, uint32_t */
 
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
 
47
                                   srand(), strtof() */
 
48
#include <stdbool.h>            /* bool, false, true */
 
49
#include <string.h>             /* memset(), strcmp(), strlen(),
 
50
                                   strerror(), asprintf(), strcpy() */
 
51
#include <sys/ioctl.h>          /* ioctl */
 
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
 
53
                                   sockaddr_in6, PF_INET6,
 
54
                                   SOCK_STREAM, uid_t, gid_t, open(),
 
55
                                   opendir(), DIR */
 
56
#include <sys/stat.h>           /* open() */
 
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
58
                                   inet_pton(), connect() */
 
59
#include <fcntl.h>              /* open() */
 
60
#include <dirent.h>             /* opendir(), struct dirent, readdir()
 
61
                                 */
 
62
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
 
63
                                   strtoimax() */
 
64
#include <assert.h>             /* assert() */
 
65
#include <errno.h>              /* perror(), errno */
 
66
#include <time.h>               /* nanosleep(), time() */
 
67
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
 
68
                                   SIOCSIFFLAGS, if_indextoname(),
 
69
                                   if_nametoindex(), IF_NAMESIZE */
 
70
#include <netinet/in.h>         /* IN6_IS_ADDR_LINKLOCAL,
 
71
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
 
72
                                */
 
73
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
 
74
                                   getuid(), getgid(), setuid(),
 
75
                                   setgid() */
 
76
#include <arpa/inet.h>          /* inet_pton(), htons */
 
77
#include <iso646.h>             /* not, or, and */
 
78
#include <argp.h>               /* struct argp_option, error_t, struct
 
79
                                   argp_state, struct argp,
 
80
                                   argp_parse(), ARGP_KEY_ARG,
 
81
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
 
82
#include <signal.h>             /* sigemptyset(), sigaddset(),
 
83
                                   sigaction(), SIGTERM, sig_atomic_t,
 
84
                                   raise() */
 
85
 
 
86
#ifdef __linux__
 
87
#include <sys/klog.h>           /* klogctl() */
 
88
#endif  /* __linux__ */
 
89
 
 
90
/* Avahi */
 
91
/* All Avahi types, constants and functions
 
92
 Avahi*, avahi_*,
 
93
 AVAHI_* */
 
94
#include <avahi-core/core.h>
 
95
#include <avahi-core/lookup.h>
 
96
#include <avahi-core/log.h>
 
97
#include <avahi-common/simple-watch.h>
 
98
#include <avahi-common/malloc.h>
 
99
#include <avahi-common/error.h>
 
100
 
 
101
/* GnuTLS */
 
102
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
 
103
                                   functions:
 
104
                                   gnutls_*
 
105
                                   init_gnutls_session(),
 
106
                                   GNUTLS_* */
 
107
#include <gnutls/openpgp.h>
 
108
                          /* gnutls_certificate_set_openpgp_key_file(),
 
109
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
110
 
 
111
/* GPGME */
 
112
#include <gpgme.h>              /* All GPGME types, constants and
 
113
                                   functions:
 
114
                                   gpgme_*
 
115
                                   GPGME_PROTOCOL_OpenPGP,
 
116
                                   GPG_ERR_NO_* */
 
117
 
 
118
#define BUFFER_SIZE 256
 
119
 
 
120
#define PATHDIR "/conf/conf.d/mandos"
 
121
#define SECKEY "seckey.txt"
 
122
#define PUBKEY "pubkey.txt"
 
123
 
 
124
bool debug = false;
 
125
static const char mandos_protocol_version[] = "1";
 
126
const char *argp_program_version = "mandos-client " VERSION;
 
127
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
128
 
 
129
/* Used for passing in values through the Avahi callback functions */
 
130
typedef struct {
 
131
  AvahiSimplePoll *simple_poll;
 
132
  AvahiServer *server;
 
133
  gnutls_certificate_credentials_t cred;
 
134
  unsigned int dh_bits;
 
135
  gnutls_dh_params_t dh_params;
 
136
  const char *priority;
 
137
  gpgme_ctx_t ctx;
 
138
} mandos_context;
 
139
 
 
140
/* global context so signal handler can reach it*/
 
141
mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
142
                      .dh_bits = 1024, .priority = "SECURE256"
 
143
                      ":!CTYPE-X.509:+CTYPE-OPENPGP" };
 
144
 
 
145
/*
 
146
 * Make additional room in "buffer" for at least BUFFER_SIZE more
 
147
 * bytes. "buffer_capacity" is how much is currently allocated,
 
148
 * "buffer_length" is how much is already used.
 
149
 */
 
150
size_t incbuffer(char **buffer, size_t buffer_length,
 
151
                  size_t buffer_capacity){
 
152
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
 
153
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
154
    if(buffer == NULL){
 
155
      return 0;
 
156
    }
 
157
    buffer_capacity += BUFFER_SIZE;
 
158
  }
 
159
  return buffer_capacity;
 
160
}
 
161
 
 
162
/* 
 
163
 * Initialize GPGME.
 
164
 */
 
165
static bool init_gpgme(const char *seckey,
 
166
                       const char *pubkey, const char *tempdir){
 
167
  int ret;
 
168
  gpgme_error_t rc;
 
169
  gpgme_engine_info_t engine_info;
 
170
  
 
171
  
 
172
  /*
 
173
   * Helper function to insert pub and seckey to the engine keyring.
 
174
   */
 
175
  bool import_key(const char *filename){
 
176
    int fd;
 
177
    gpgme_data_t pgp_data;
 
178
    
 
179
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
180
    if(fd == -1){
 
181
      perror("open");
 
182
      return false;
 
183
    }
 
184
    
 
185
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
186
    if(rc != GPG_ERR_NO_ERROR){
 
187
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
188
              gpgme_strsource(rc), gpgme_strerror(rc));
 
189
      return false;
 
190
    }
 
191
    
 
192
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
193
    if(rc != GPG_ERR_NO_ERROR){
 
194
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
 
195
              gpgme_strsource(rc), gpgme_strerror(rc));
 
196
      return false;
 
197
    }
 
198
    
 
199
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
200
    if(ret == -1){
 
201
      perror("close");
 
202
    }
 
203
    gpgme_data_release(pgp_data);
 
204
    return true;
 
205
  }
 
206
  
 
207
  if(debug){
 
208
    fprintf(stderr, "Initializing GPGME\n");
 
209
  }
 
210
  
 
211
  /* Init GPGME */
 
212
  gpgme_check_version(NULL);
 
213
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
214
  if(rc != GPG_ERR_NO_ERROR){
 
215
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
216
            gpgme_strsource(rc), gpgme_strerror(rc));
 
217
    return false;
 
218
  }
 
219
  
 
220
    /* Set GPGME home directory for the OpenPGP engine only */
 
221
  rc = gpgme_get_engine_info(&engine_info);
 
222
  if(rc != GPG_ERR_NO_ERROR){
 
223
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
224
            gpgme_strsource(rc), gpgme_strerror(rc));
 
225
    return false;
 
226
  }
 
227
  while(engine_info != NULL){
 
228
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
 
229
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
 
230
                            engine_info->file_name, tempdir);
 
231
      break;
 
232
    }
 
233
    engine_info = engine_info->next;
 
234
  }
 
235
  if(engine_info == NULL){
 
236
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
237
    return false;
 
238
  }
 
239
  
 
240
  /* Create new GPGME "context" */
 
241
  rc = gpgme_new(&(mc.ctx));
 
242
  if(rc != GPG_ERR_NO_ERROR){
 
243
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
244
            gpgme_strsource(rc), gpgme_strerror(rc));
 
245
    return false;
 
246
  }
 
247
  
 
248
  if(not import_key(pubkey) or not import_key(seckey)){
 
249
    return false;
 
250
  }
 
251
  
 
252
  return true;
 
253
}
 
254
 
 
255
/* 
 
256
 * Decrypt OpenPGP data.
 
257
 * Returns -1 on error
 
258
 */
 
259
static ssize_t pgp_packet_decrypt(const char *cryptotext,
 
260
                                  size_t crypto_size,
 
261
                                  char **plaintext){
 
262
  gpgme_data_t dh_crypto, dh_plain;
 
263
  gpgme_error_t rc;
 
264
  ssize_t ret;
 
265
  size_t plaintext_capacity = 0;
 
266
  ssize_t plaintext_length = 0;
 
267
  
 
268
  if(debug){
 
269
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
270
  }
 
271
  
 
272
  /* Create new GPGME data buffer from memory cryptotext */
 
273
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
274
                               0);
 
275
  if(rc != GPG_ERR_NO_ERROR){
 
276
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
277
            gpgme_strsource(rc), gpgme_strerror(rc));
 
278
    return -1;
 
279
  }
 
280
  
 
281
  /* Create new empty GPGME data buffer for the plaintext */
 
282
  rc = gpgme_data_new(&dh_plain);
 
283
  if(rc != GPG_ERR_NO_ERROR){
 
284
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
285
            gpgme_strsource(rc), gpgme_strerror(rc));
 
286
    gpgme_data_release(dh_crypto);
 
287
    return -1;
 
288
  }
 
289
  
 
290
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
291
     data buffer */
 
292
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
293
  if(rc != GPG_ERR_NO_ERROR){
 
294
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
295
            gpgme_strsource(rc), gpgme_strerror(rc));
 
296
    plaintext_length = -1;
 
297
    if(debug){
 
298
      gpgme_decrypt_result_t result;
 
299
      result = gpgme_op_decrypt_result(mc.ctx);
 
300
      if(result == NULL){
 
301
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
302
      } else {
 
303
        fprintf(stderr, "Unsupported algorithm: %s\n",
 
304
                result->unsupported_algorithm);
 
305
        fprintf(stderr, "Wrong key usage: %u\n",
 
306
                result->wrong_key_usage);
 
307
        if(result->file_name != NULL){
 
308
          fprintf(stderr, "File name: %s\n", result->file_name);
 
309
        }
 
310
        gpgme_recipient_t recipient;
 
311
        recipient = result->recipients;
 
312
        while(recipient != NULL){
 
313
          fprintf(stderr, "Public key algorithm: %s\n",
 
314
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
315
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
316
          fprintf(stderr, "Secret key available: %s\n",
 
317
                  recipient->status == GPG_ERR_NO_SECKEY
 
318
                  ? "No" : "Yes");
 
319
          recipient = recipient->next;
 
320
        }
 
321
      }
 
322
    }
 
323
    goto decrypt_end;
 
324
  }
 
325
  
 
326
  if(debug){
 
327
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
328
  }
 
329
  
 
330
  /* Seek back to the beginning of the GPGME plaintext data buffer */
 
331
  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
 
332
    perror("gpgme_data_seek");
 
333
    plaintext_length = -1;
 
334
    goto decrypt_end;
 
335
  }
 
336
  
 
337
  *plaintext = NULL;
 
338
  while(true){
 
339
    plaintext_capacity = incbuffer(plaintext,
 
340
                                      (size_t)plaintext_length,
 
341
                                      plaintext_capacity);
 
342
    if(plaintext_capacity == 0){
 
343
        perror("incbuffer");
 
344
        plaintext_length = -1;
 
345
        goto decrypt_end;
 
346
    }
 
347
    
 
348
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
349
                          BUFFER_SIZE);
 
350
    /* Print the data, if any */
 
351
    if(ret == 0){
 
352
      /* EOF */
 
353
      break;
 
354
    }
 
355
    if(ret < 0){
 
356
      perror("gpgme_data_read");
 
357
      plaintext_length = -1;
 
358
      goto decrypt_end;
 
359
    }
 
360
    plaintext_length += ret;
 
361
  }
 
362
  
 
363
  if(debug){
 
364
    fprintf(stderr, "Decrypted password is: ");
 
365
    for(ssize_t i = 0; i < plaintext_length; i++){
 
366
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
 
367
    }
 
368
    fprintf(stderr, "\n");
 
369
  }
 
370
  
 
371
 decrypt_end:
 
372
  
 
373
  /* Delete the GPGME cryptotext data buffer */
 
374
  gpgme_data_release(dh_crypto);
 
375
  
 
376
  /* Delete the GPGME plaintext data buffer */
 
377
  gpgme_data_release(dh_plain);
 
378
  return plaintext_length;
 
379
}
 
380
 
 
381
static const char * safer_gnutls_strerror(int value){
 
382
  const char *ret = gnutls_strerror(value); /* Spurious warning from
 
383
                                               -Wunreachable-code */
 
384
  if(ret == NULL)
 
385
    ret = "(unknown)";
 
386
  return ret;
 
387
}
 
388
 
 
389
/* GnuTLS log function callback */
 
390
static void debuggnutls(__attribute__((unused)) int level,
 
391
                        const char* string){
 
392
  fprintf(stderr, "GnuTLS: %s", string);
 
393
}
 
394
 
 
395
static int init_gnutls_global(const char *pubkeyfilename,
 
396
                              const char *seckeyfilename){
 
397
  int ret;
 
398
  
 
399
  if(debug){
 
400
    fprintf(stderr, "Initializing GnuTLS\n");
 
401
  }
 
402
  
 
403
  ret = gnutls_global_init();
 
404
  if(ret != GNUTLS_E_SUCCESS){
 
405
    fprintf(stderr, "GnuTLS global_init: %s\n",
 
406
            safer_gnutls_strerror(ret));
 
407
    return -1;
 
408
  }
 
409
  
 
410
  if(debug){
 
411
    /* "Use a log level over 10 to enable all debugging options."
 
412
     * - GnuTLS manual
 
413
     */
 
414
    gnutls_global_set_log_level(11);
 
415
    gnutls_global_set_log_function(debuggnutls);
 
416
  }
 
417
  
 
418
  /* OpenPGP credentials */
 
419
  gnutls_certificate_allocate_credentials(&mc.cred);
 
420
  if(ret != GNUTLS_E_SUCCESS){
 
421
    fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
 
422
                                                    from
 
423
                                                    -Wunreachable-code
 
424
                                                 */
 
425
            safer_gnutls_strerror(ret));
 
426
    gnutls_global_deinit();
 
427
    return -1;
 
428
  }
 
429
  
 
430
  if(debug){
 
431
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
432
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
 
433
            seckeyfilename);
 
434
  }
 
435
  
 
436
  ret = gnutls_certificate_set_openpgp_key_file
 
437
    (mc.cred, pubkeyfilename, seckeyfilename,
 
438
     GNUTLS_OPENPGP_FMT_BASE64);
 
439
  if(ret != GNUTLS_E_SUCCESS){
 
440
    fprintf(stderr,
 
441
            "Error[%d] while reading the OpenPGP key pair ('%s',"
 
442
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
443
    fprintf(stderr, "The GnuTLS error is: %s\n",
 
444
            safer_gnutls_strerror(ret));
 
445
    goto globalfail;
 
446
  }
 
447
  
 
448
  /* GnuTLS server initialization */
 
449
  ret = gnutls_dh_params_init(&mc.dh_params);
 
450
  if(ret != GNUTLS_E_SUCCESS){
 
451
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
 
452
            " %s\n", safer_gnutls_strerror(ret));
 
453
    goto globalfail;
 
454
  }
 
455
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
456
  if(ret != GNUTLS_E_SUCCESS){
 
457
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
 
458
            safer_gnutls_strerror(ret));
 
459
    goto globalfail;
 
460
  }
 
461
  
 
462
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
463
  
 
464
  return 0;
 
465
  
 
466
 globalfail:
 
467
  
 
468
  gnutls_certificate_free_credentials(mc.cred);
 
469
  gnutls_global_deinit();
 
470
  gnutls_dh_params_deinit(mc.dh_params);
 
471
  return -1;
 
472
}
 
473
 
 
474
static int init_gnutls_session(gnutls_session_t *session){
 
475
  int ret;
 
476
  /* GnuTLS session creation */
 
477
  ret = gnutls_init(session, GNUTLS_SERVER);
 
478
  if(ret != GNUTLS_E_SUCCESS){
 
479
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
 
480
            safer_gnutls_strerror(ret));
 
481
  }
 
482
  
 
483
  {
 
484
    const char *err;
 
485
    ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
486
    if(ret != GNUTLS_E_SUCCESS){
 
487
      fprintf(stderr, "Syntax error at: %s\n", err);
 
488
      fprintf(stderr, "GnuTLS error: %s\n",
 
489
              safer_gnutls_strerror(ret));
 
490
      gnutls_deinit(*session);
 
491
      return -1;
 
492
    }
 
493
  }
 
494
  
 
495
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
496
                               mc.cred);
 
497
  if(ret != GNUTLS_E_SUCCESS){
 
498
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
 
499
            safer_gnutls_strerror(ret));
 
500
    gnutls_deinit(*session);
 
501
    return -1;
 
502
  }
 
503
  
 
504
  /* ignore client certificate if any. */
 
505
  gnutls_certificate_server_set_request(*session,
 
506
                                        GNUTLS_CERT_IGNORE);
 
507
  
 
508
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
509
  
 
510
  return 0;
 
511
}
 
512
 
 
513
/* Avahi log function callback */
 
514
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
515
                      __attribute__((unused)) const char *txt){}
 
516
 
 
517
sig_atomic_t quit_now = 0;
 
518
int signal_received = 0;
 
519
 
 
520
/* Called when a Mandos server is found */
 
521
static int start_mandos_communication(const char *ip, uint16_t port,
 
522
                                      AvahiIfIndex if_index,
 
523
                                      int af){
 
524
  int ret, tcp_sd = -1;
 
525
  ssize_t sret;
 
526
  union {
 
527
    struct sockaddr_in in;
 
528
    struct sockaddr_in6 in6;
 
529
  } to;
 
530
  char *buffer = NULL;
 
531
  char *decrypted_buffer;
 
532
  size_t buffer_length = 0;
 
533
  size_t buffer_capacity = 0;
 
534
  ssize_t decrypted_buffer_size;
 
535
  size_t written;
 
536
  int retval = 0;
 
537
  gnutls_session_t session;
 
538
  int pf;                       /* Protocol family */
 
539
  
 
540
  if(quit_now){
 
541
    return -1;
 
542
  }
 
543
  
 
544
  switch(af){
 
545
  case AF_INET6:
 
546
    pf = PF_INET6;
 
547
    break;
 
548
  case AF_INET:
 
549
    pf = PF_INET;
 
550
    break;
 
551
  default:
 
552
    fprintf(stderr, "Bad address family: %d\n", af);
 
553
    return -1;
 
554
  }
 
555
  
 
556
  ret = init_gnutls_session(&session);
 
557
  if(ret != 0){
 
558
    return -1;
 
559
  }
 
560
  
 
561
  if(debug){
 
562
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
 
563
            "\n", ip, port);
 
564
  }
 
565
  
 
566
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
567
  if(tcp_sd < 0){
 
568
    perror("socket");
 
569
    retval = -1;
 
570
    goto mandos_end;
 
571
  }
 
572
  
 
573
  if(quit_now){
 
574
    goto mandos_end;
 
575
  }
 
576
  
 
577
  memset(&to, 0, sizeof(to));
 
578
  if(af == AF_INET6){
 
579
    to.in6.sin6_family = (sa_family_t)af;
 
580
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
581
  } else {                      /* IPv4 */
 
582
    to.in.sin_family = (sa_family_t)af;
 
583
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
584
  }
 
585
  if(ret < 0 ){
 
586
    perror("inet_pton");
 
587
    retval = -1;
 
588
    goto mandos_end;
 
589
  }
 
590
  if(ret == 0){
 
591
    fprintf(stderr, "Bad address: %s\n", ip);
 
592
    retval = -1;
 
593
    goto mandos_end;
 
594
  }
 
595
  if(af == AF_INET6){
 
596
    to.in6.sin6_port = htons(port); /* Spurious warnings from
 
597
                                       -Wconversion and
 
598
                                       -Wunreachable-code */
 
599
    
 
600
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
 
601
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
 
602
                              -Wunreachable-code*/
 
603
      if(if_index == AVAHI_IF_UNSPEC){
 
604
        fprintf(stderr, "An IPv6 link-local address is incomplete"
 
605
                " without a network interface\n");
 
606
        retval = -1;
 
607
        goto mandos_end;
 
608
      }
 
609
      /* Set the network interface number as scope */
 
610
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
611
    }
 
612
  } else {
 
613
    to.in.sin_port = htons(port); /* Spurious warnings from
 
614
                                     -Wconversion and
 
615
                                     -Wunreachable-code */
 
616
  }
 
617
  
 
618
  if(quit_now){
 
619
    goto mandos_end;
 
620
  }
 
621
  
 
622
  if(debug){
 
623
    if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
 
624
      char interface[IF_NAMESIZE];
 
625
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
626
        perror("if_indextoname");
 
627
      } else {
 
628
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
 
629
                ip, interface, port);
 
630
      }
 
631
    } else {
 
632
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
 
633
              port);
 
634
    }
 
635
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
 
636
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
 
637
    const char *pcret;
 
638
    if(af == AF_INET6){
 
639
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
 
640
                        sizeof(addrstr));
 
641
    } else {
 
642
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
 
643
                        sizeof(addrstr));
 
644
    }
 
645
    if(pcret == NULL){
 
646
      perror("inet_ntop");
 
647
    } else {
 
648
      if(strcmp(addrstr, ip) != 0){
 
649
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
 
650
      }
 
651
    }
 
652
  }
 
653
  
 
654
  if(quit_now){
 
655
    goto mandos_end;
 
656
  }
 
657
  
 
658
  if(af == AF_INET6){
 
659
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
660
  } else {
 
661
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
662
  }
 
663
  if(ret < 0){
 
664
    perror("connect");
 
665
    retval = -1;
 
666
    goto mandos_end;
 
667
  }
 
668
  
 
669
  if(quit_now){
 
670
    goto mandos_end;
 
671
  }
 
672
  
 
673
  const char *out = mandos_protocol_version;
 
674
  written = 0;
 
675
  while(true){
 
676
    size_t out_size = strlen(out);
 
677
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
 
678
                                   out_size - written));
 
679
    if(ret == -1){
 
680
      perror("write");
 
681
      retval = -1;
 
682
      goto mandos_end;
 
683
    }
 
684
    written += (size_t)ret;
 
685
    if(written < out_size){
 
686
      continue;
 
687
    } else {
 
688
      if(out == mandos_protocol_version){
 
689
        written = 0;
 
690
        out = "\r\n";
 
691
      } else {
 
692
        break;
 
693
      }
 
694
    }
 
695
  
 
696
    if(quit_now){
 
697
      goto mandos_end;
 
698
    }
 
699
  }
 
700
  
 
701
  if(debug){
 
702
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
703
  }
 
704
  
 
705
  if(quit_now){
 
706
    goto mandos_end;
 
707
  }
 
708
  
 
709
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
710
  
 
711
  if(quit_now){
 
712
    goto mandos_end;
 
713
  }
 
714
  
 
715
  do{
 
716
    ret = gnutls_handshake(session);
 
717
    if(quit_now){
 
718
      goto mandos_end;
 
719
    }
 
720
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
721
  
 
722
  if(ret != GNUTLS_E_SUCCESS){
 
723
    if(debug){
 
724
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
725
      gnutls_perror(ret);
 
726
    }
 
727
    retval = -1;
 
728
    goto mandos_end;
 
729
  }
 
730
  
 
731
  /* Read OpenPGP packet that contains the wanted password */
 
732
  
 
733
  if(debug){
 
734
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
 
735
            ip);
 
736
  }
 
737
  
 
738
  while(true){
 
739
    
 
740
    if(quit_now){
 
741
      goto mandos_end;
 
742
    }
 
743
    
 
744
    buffer_capacity = incbuffer(&buffer, buffer_length,
 
745
                                   buffer_capacity);
 
746
    if(buffer_capacity == 0){
 
747
      perror("incbuffer");
 
748
      retval = -1;
 
749
      goto mandos_end;
 
750
    }
 
751
    
 
752
    if(quit_now){
 
753
      goto mandos_end;
 
754
    }
 
755
    
 
756
    sret = gnutls_record_recv(session, buffer+buffer_length,
 
757
                              BUFFER_SIZE);
 
758
    if(sret == 0){
 
759
      break;
 
760
    }
 
761
    if(sret < 0){
 
762
      switch(sret){
 
763
      case GNUTLS_E_INTERRUPTED:
 
764
      case GNUTLS_E_AGAIN:
 
765
        break;
 
766
      case GNUTLS_E_REHANDSHAKE:
 
767
        do{
 
768
          ret = gnutls_handshake(session);
 
769
          
 
770
          if(quit_now){
 
771
            goto mandos_end;
 
772
          }
 
773
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
774
        if(ret < 0){
 
775
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
776
          gnutls_perror(ret);
 
777
          retval = -1;
 
778
          goto mandos_end;
 
779
        }
 
780
        break;
 
781
      default:
 
782
        fprintf(stderr, "Unknown error while reading data from"
 
783
                " encrypted session with Mandos server\n");
 
784
        retval = -1;
 
785
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
786
        goto mandos_end;
 
787
      }
 
788
    } else {
 
789
      buffer_length += (size_t) sret;
 
790
    }
 
791
  }
 
792
  
 
793
  if(debug){
 
794
    fprintf(stderr, "Closing TLS session\n");
 
795
  }
 
796
  
 
797
  if(quit_now){
 
798
    goto mandos_end;
 
799
  }
 
800
  
 
801
  gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
802
  
 
803
  if(quit_now){
 
804
    goto mandos_end;
 
805
  }
 
806
  
 
807
  if(buffer_length > 0){
 
808
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
809
                                               buffer_length,
 
810
                                               &decrypted_buffer);
 
811
    if(decrypted_buffer_size >= 0){
 
812
      written = 0;
 
813
      while(written < (size_t) decrypted_buffer_size){
 
814
        if(quit_now){
 
815
          goto mandos_end;
 
816
        }
 
817
        
 
818
        ret = (int)fwrite(decrypted_buffer + written, 1,
 
819
                          (size_t)decrypted_buffer_size - written,
 
820
                          stdout);
 
821
        if(ret == 0 and ferror(stdout)){
 
822
          if(debug){
 
823
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
824
                    strerror(errno));
 
825
          }
 
826
          retval = -1;
 
827
          break;
 
828
        }
 
829
        written += (size_t)ret;
 
830
      }
 
831
      free(decrypted_buffer);
 
832
    } else {
 
833
      retval = -1;
 
834
    }
 
835
  } else {
 
836
    retval = -1;
 
837
  }
 
838
  
 
839
  /* Shutdown procedure */
 
840
  
 
841
 mandos_end:
 
842
  free(buffer);
 
843
  if(tcp_sd >= 0){
 
844
    ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
845
  }
 
846
  if(ret == -1){
 
847
    perror("close");
 
848
  }
 
849
  gnutls_deinit(session);
 
850
  if(quit_now){
 
851
    retval = -1;
 
852
  }
 
853
  return retval;
 
854
}
 
855
 
 
856
static void resolve_callback(AvahiSServiceResolver *r,
 
857
                             AvahiIfIndex interface,
 
858
                             AvahiProtocol proto,
 
859
                             AvahiResolverEvent event,
 
860
                             const char *name,
 
861
                             const char *type,
 
862
                             const char *domain,
 
863
                             const char *host_name,
 
864
                             const AvahiAddress *address,
 
865
                             uint16_t port,
 
866
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
 
867
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
868
                             flags,
 
869
                             AVAHI_GCC_UNUSED void* userdata){
 
870
  assert(r);
 
871
  
 
872
  /* Called whenever a service has been resolved successfully or
 
873
     timed out */
 
874
  
 
875
  if(quit_now){
 
876
    return;
 
877
  }
 
878
  
 
879
  switch(event){
 
880
  default:
 
881
  case AVAHI_RESOLVER_FAILURE:
 
882
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
 
883
            " of type '%s' in domain '%s': %s\n", name, type, domain,
 
884
            avahi_strerror(avahi_server_errno(mc.server)));
 
885
    break;
 
886
    
 
887
  case AVAHI_RESOLVER_FOUND:
 
888
    {
 
889
      char ip[AVAHI_ADDRESS_STR_MAX];
 
890
      avahi_address_snprint(ip, sizeof(ip), address);
 
891
      if(debug){
 
892
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
893
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
 
894
                ip, (intmax_t)interface, port);
 
895
      }
 
896
      int ret = start_mandos_communication(ip, port, interface,
 
897
                                           avahi_proto_to_af(proto));
 
898
      if(ret == 0){
 
899
        avahi_simple_poll_quit(mc.simple_poll);
 
900
      }
 
901
    }
 
902
  }
 
903
  avahi_s_service_resolver_free(r);
 
904
}
 
905
 
 
906
static void browse_callback(AvahiSServiceBrowser *b,
 
907
                            AvahiIfIndex interface,
 
908
                            AvahiProtocol protocol,
 
909
                            AvahiBrowserEvent event,
 
910
                            const char *name,
 
911
                            const char *type,
 
912
                            const char *domain,
 
913
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
914
                            flags,
 
915
                            AVAHI_GCC_UNUSED void* userdata){
 
916
  assert(b);
 
917
  
 
918
  /* Called whenever a new services becomes available on the LAN or
 
919
     is removed from the LAN */
 
920
  
 
921
  if(quit_now){
 
922
    return;
 
923
  }
 
924
  
 
925
  switch(event){
 
926
  default:
 
927
  case AVAHI_BROWSER_FAILURE:
 
928
    
 
929
    fprintf(stderr, "(Avahi browser) %s\n",
 
930
            avahi_strerror(avahi_server_errno(mc.server)));
 
931
    avahi_simple_poll_quit(mc.simple_poll);
 
932
    return;
 
933
    
 
934
  case AVAHI_BROWSER_NEW:
 
935
    /* We ignore the returned Avahi resolver object. In the callback
 
936
       function we free it. If the Avahi server is terminated before
 
937
       the callback function is called the Avahi server will free the
 
938
       resolver for us. */
 
939
    
 
940
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
 
941
                                    name, type, domain, protocol, 0,
 
942
                                    resolve_callback, NULL) == NULL)
 
943
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
 
944
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
945
    break;
 
946
    
 
947
  case AVAHI_BROWSER_REMOVE:
 
948
    break;
 
949
    
 
950
  case AVAHI_BROWSER_ALL_FOR_NOW:
 
951
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
952
    if(debug){
 
953
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
954
    }
 
955
    break;
 
956
  }
 
957
}
 
958
 
 
959
/* stop main loop after sigterm has been called */
 
960
static void handle_sigterm(int sig){
 
961
  if(quit_now){
 
962
    return;
 
963
  }
 
964
  quit_now = 1;
 
965
  signal_received = sig;
 
966
  int old_errno = errno;
 
967
  if(mc.simple_poll != NULL){
 
968
    avahi_simple_poll_quit(mc.simple_poll);
 
969
  }
 
970
  errno = old_errno;
 
971
}
 
972
 
 
973
int main(int argc, char *argv[]){
 
974
  AvahiSServiceBrowser *sb = NULL;
 
975
  int error;
 
976
  int ret;
 
977
  intmax_t tmpmax;
 
978
  char *tmp;
 
979
  int exitcode = EXIT_SUCCESS;
 
980
  const char *interface = "eth0";
 
981
  struct ifreq network;
 
982
  int sd = -1;
 
983
  bool take_down_interface = false;
 
984
  uid_t uid;
 
985
  gid_t gid;
 
986
  char *connect_to = NULL;
 
987
  char tempdir[] = "/tmp/mandosXXXXXX";
 
988
  bool tempdir_created = false;
 
989
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
990
  const char *seckey = PATHDIR "/" SECKEY;
 
991
  const char *pubkey = PATHDIR "/" PUBKEY;
 
992
  
 
993
  bool gnutls_initialized = false;
 
994
  bool gpgme_initialized = false;
 
995
  float delay = 2.5f;
 
996
  
 
997
  struct sigaction old_sigterm_action;
 
998
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
 
999
  
 
1000
  {
 
1001
    struct argp_option options[] = {
 
1002
      { .name = "debug", .key = 128,
 
1003
        .doc = "Debug mode", .group = 3 },
 
1004
      { .name = "connect", .key = 'c',
 
1005
        .arg = "ADDRESS:PORT",
 
1006
        .doc = "Connect directly to a specific Mandos server",
 
1007
        .group = 1 },
 
1008
      { .name = "interface", .key = 'i',
 
1009
        .arg = "NAME",
 
1010
        .doc = "Network interface that will be used to search for"
 
1011
        " Mandos servers",
 
1012
        .group = 1 },
 
1013
      { .name = "seckey", .key = 's',
 
1014
        .arg = "FILE",
 
1015
        .doc = "OpenPGP secret key file base name",
 
1016
        .group = 1 },
 
1017
      { .name = "pubkey", .key = 'p',
 
1018
        .arg = "FILE",
 
1019
        .doc = "OpenPGP public key file base name",
 
1020
        .group = 2 },
 
1021
      { .name = "dh-bits", .key = 129,
 
1022
        .arg = "BITS",
 
1023
        .doc = "Bit length of the prime number used in the"
 
1024
        " Diffie-Hellman key exchange",
 
1025
        .group = 2 },
 
1026
      { .name = "priority", .key = 130,
 
1027
        .arg = "STRING",
 
1028
        .doc = "GnuTLS priority string for the TLS handshake",
 
1029
        .group = 1 },
 
1030
      { .name = "delay", .key = 131,
 
1031
        .arg = "SECONDS",
 
1032
        .doc = "Maximum delay to wait for interface startup",
 
1033
        .group = 2 },
 
1034
      { .name = NULL }
 
1035
    };
 
1036
    
 
1037
    error_t parse_opt(int key, char *arg,
 
1038
                      struct argp_state *state){
 
1039
      switch(key){
 
1040
      case 128:                 /* --debug */
 
1041
        debug = true;
 
1042
        break;
 
1043
      case 'c':                 /* --connect */
 
1044
        connect_to = arg;
 
1045
        break;
 
1046
      case 'i':                 /* --interface */
 
1047
        interface = arg;
 
1048
        break;
 
1049
      case 's':                 /* --seckey */
 
1050
        seckey = arg;
 
1051
        break;
 
1052
      case 'p':                 /* --pubkey */
 
1053
        pubkey = arg;
 
1054
        break;
 
1055
      case 129:                 /* --dh-bits */
 
1056
        errno = 0;
 
1057
        tmpmax = strtoimax(arg, &tmp, 10);
 
1058
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1059
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
 
1060
          fprintf(stderr, "Bad number of DH bits\n");
 
1061
          exit(EXIT_FAILURE);
 
1062
        }
 
1063
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
 
1064
        break;
 
1065
      case 130:                 /* --priority */
 
1066
        mc.priority = arg;
 
1067
        break;
 
1068
      case 131:                 /* --delay */
 
1069
        errno = 0;
 
1070
        delay = strtof(arg, &tmp);
 
1071
        if(errno != 0 or tmp == arg or *tmp != '\0'){
 
1072
          fprintf(stderr, "Bad delay\n");
 
1073
          exit(EXIT_FAILURE);
 
1074
        }
 
1075
        break;
 
1076
      case ARGP_KEY_ARG:
 
1077
        argp_usage(state);
 
1078
      case ARGP_KEY_END:
 
1079
        break;
 
1080
      default:
 
1081
        return ARGP_ERR_UNKNOWN;
 
1082
      }
 
1083
      return 0;
 
1084
    }
 
1085
    
 
1086
    struct argp argp = { .options = options, .parser = parse_opt,
 
1087
                         .args_doc = "",
 
1088
                         .doc = "Mandos client -- Get and decrypt"
 
1089
                         " passwords from a Mandos server" };
 
1090
    ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
 
1091
    if(ret == ARGP_ERR_UNKNOWN){
 
1092
      fprintf(stderr, "Unknown error while parsing arguments\n");
 
1093
      exitcode = EXIT_FAILURE;
 
1094
      goto end;
 
1095
    }
 
1096
  }
 
1097
  
 
1098
  if(not debug){
 
1099
    avahi_set_log_function(empty_log);
 
1100
  }
 
1101
  
 
1102
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
 
1103
     from the signal handler */
 
1104
  /* Initialize the pseudo-RNG for Avahi */
 
1105
  srand((unsigned int) time(NULL));
 
1106
  mc.simple_poll = avahi_simple_poll_new();
 
1107
  if(mc.simple_poll == NULL){
 
1108
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
1109
    exitcode = EXIT_FAILURE;
 
1110
    goto end;
 
1111
  }
 
1112
  
 
1113
  sigemptyset(&sigterm_action.sa_mask);
 
1114
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
 
1115
  if(ret == -1){
 
1116
    perror("sigaddset");
 
1117
    exitcode = EXIT_FAILURE;
 
1118
    goto end;
 
1119
  }
 
1120
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
 
1121
  if(ret == -1){
 
1122
    perror("sigaddset");
 
1123
    exitcode = EXIT_FAILURE;
 
1124
    goto end;
 
1125
  }
 
1126
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
 
1127
  if(ret == -1){
 
1128
    perror("sigaddset");
 
1129
    exitcode = EXIT_FAILURE;
 
1130
    goto end;
 
1131
  }
 
1132
  /* Need to check if the handler is SIG_IGN before handling:
 
1133
     | [[info:libc:Initial Signal Actions]] |
 
1134
     | [[info:libc:Basic Signal Handling]]  |
 
1135
  */
 
1136
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
 
1137
  if(ret == -1){
 
1138
    perror("sigaction");
 
1139
    return EXIT_FAILURE;
 
1140
  }
 
1141
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1142
    ret = sigaction(SIGINT, &sigterm_action, NULL);
 
1143
    if(ret == -1){
 
1144
      perror("sigaction");
 
1145
      exitcode = EXIT_FAILURE;
 
1146
      goto end;
 
1147
    }
 
1148
  }
 
1149
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
 
1150
  if(ret == -1){
 
1151
    perror("sigaction");
 
1152
    return EXIT_FAILURE;
 
1153
  }
 
1154
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1155
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
 
1156
    if(ret == -1){
 
1157
      perror("sigaction");
 
1158
      exitcode = EXIT_FAILURE;
 
1159
      goto end;
 
1160
    }
 
1161
  }
 
1162
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
 
1163
  if(ret == -1){
 
1164
    perror("sigaction");
 
1165
    return EXIT_FAILURE;
 
1166
  }
 
1167
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1168
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
 
1169
    if(ret == -1){
 
1170
      perror("sigaction");
 
1171
      exitcode = EXIT_FAILURE;
 
1172
      goto end;
 
1173
    }
 
1174
  }
 
1175
  
 
1176
  /* If the interface is down, bring it up */
 
1177
  if(interface[0] != '\0'){
 
1178
    if_index = (AvahiIfIndex) if_nametoindex(interface);
 
1179
    if(if_index == 0){
 
1180
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
1181
      exitcode = EXIT_FAILURE;
 
1182
      goto end;
 
1183
    }
 
1184
    
 
1185
    if(quit_now){
 
1186
      goto end;
 
1187
    }
 
1188
    
 
1189
#ifdef __linux__
 
1190
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1191
       messages to mess up the prompt */
 
1192
    ret = klogctl(8, NULL, 5);
 
1193
    bool restore_loglevel = true;
 
1194
    if(ret == -1){
 
1195
      restore_loglevel = false;
 
1196
      perror("klogctl");
 
1197
    }
 
1198
#endif  /* __linux__ */
 
1199
    
 
1200
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1201
    if(sd < 0){
 
1202
      perror("socket");
 
1203
      exitcode = EXIT_FAILURE;
 
1204
#ifdef __linux__
 
1205
      if(restore_loglevel){
 
1206
        ret = klogctl(7, NULL, 0);
 
1207
        if(ret == -1){
 
1208
          perror("klogctl");
 
1209
        }
 
1210
      }
 
1211
#endif  /* __linux__ */
 
1212
      goto end;
 
1213
    }
 
1214
    strcpy(network.ifr_name, interface);
 
1215
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1216
    if(ret == -1){
 
1217
      perror("ioctl SIOCGIFFLAGS");
 
1218
#ifdef __linux__
 
1219
      if(restore_loglevel){
 
1220
        ret = klogctl(7, NULL, 0);
 
1221
        if(ret == -1){
 
1222
          perror("klogctl");
 
1223
        }
 
1224
      }
 
1225
#endif  /* __linux__ */
 
1226
      exitcode = EXIT_FAILURE;
 
1227
      goto end;
 
1228
    }
 
1229
    if((network.ifr_flags & IFF_UP) == 0){
 
1230
      network.ifr_flags |= IFF_UP;
 
1231
      take_down_interface = true;
 
1232
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1233
      if(ret == -1){
 
1234
        take_down_interface = false;
 
1235
        perror("ioctl SIOCSIFFLAGS");
 
1236
        exitcode = EXIT_FAILURE;
 
1237
#ifdef __linux__
 
1238
        if(restore_loglevel){
 
1239
          ret = klogctl(7, NULL, 0);
 
1240
          if(ret == -1){
 
1241
            perror("klogctl");
 
1242
          }
 
1243
        }
 
1244
#endif  /* __linux__ */
 
1245
        goto end;
 
1246
      }
 
1247
    }
 
1248
    /* sleep checking until interface is running */
 
1249
    for(int i=0; i < delay * 4; i++){
 
1250
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1251
      if(ret == -1){
 
1252
        perror("ioctl SIOCGIFFLAGS");
 
1253
      } else if(network.ifr_flags & IFF_RUNNING){
 
1254
        break;
 
1255
      }
 
1256
      struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1257
      ret = nanosleep(&sleeptime, NULL);
 
1258
      if(ret == -1 and errno != EINTR){
 
1259
        perror("nanosleep");
 
1260
      }
 
1261
    }
 
1262
    if(not take_down_interface){
 
1263
      /* We won't need the socket anymore */
 
1264
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1265
      if(ret == -1){
 
1266
        perror("close");
 
1267
      }
 
1268
    }
 
1269
#ifdef __linux__
 
1270
    if(restore_loglevel){
 
1271
      /* Restores kernel loglevel to default */
 
1272
      ret = klogctl(7, NULL, 0);
 
1273
      if(ret == -1){
 
1274
        perror("klogctl");
 
1275
      }
 
1276
    }
 
1277
#endif  /* __linux__ */
 
1278
  }
 
1279
  
 
1280
  if(quit_now){
 
1281
    goto end;
 
1282
  }
 
1283
  
 
1284
  uid = getuid();
 
1285
  gid = getgid();
 
1286
  
 
1287
  errno = 0;
 
1288
  setgid(gid);
 
1289
  if(ret == -1){
 
1290
    perror("setgid");
 
1291
  }
 
1292
  
 
1293
  ret = setuid(uid);
 
1294
  if(ret == -1){
 
1295
    perror("setuid");
 
1296
  }
 
1297
  
 
1298
  if(quit_now){
 
1299
    goto end;
 
1300
  }
 
1301
  
 
1302
  ret = init_gnutls_global(pubkey, seckey);
 
1303
  if(ret == -1){
 
1304
    fprintf(stderr, "init_gnutls_global failed\n");
 
1305
    exitcode = EXIT_FAILURE;
 
1306
    goto end;
 
1307
  } else {
 
1308
    gnutls_initialized = true;
 
1309
  }
 
1310
  
 
1311
  if(quit_now){
 
1312
    goto end;
 
1313
  }
 
1314
  
 
1315
  tempdir_created = true;
 
1316
  if(mkdtemp(tempdir) == NULL){
 
1317
    tempdir_created = false;
 
1318
    perror("mkdtemp");
 
1319
    goto end;
 
1320
  }
 
1321
  
 
1322
  if(quit_now){
 
1323
    goto end;
 
1324
  }
 
1325
  
 
1326
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
1327
    fprintf(stderr, "init_gpgme failed\n");
 
1328
    exitcode = EXIT_FAILURE;
 
1329
    goto end;
 
1330
  } else {
 
1331
    gpgme_initialized = true;
 
1332
  }
 
1333
  
 
1334
  if(quit_now){
 
1335
    goto end;
 
1336
  }
 
1337
  
 
1338
  if(connect_to != NULL){
 
1339
    /* Connect directly, do not use Zeroconf */
 
1340
    /* (Mainly meant for debugging) */
 
1341
    char *address = strrchr(connect_to, ':');
 
1342
    if(address == NULL){
 
1343
      fprintf(stderr, "No colon in address\n");
 
1344
      exitcode = EXIT_FAILURE;
 
1345
      goto end;
 
1346
    }
 
1347
    
 
1348
    if(quit_now){
 
1349
      goto end;
 
1350
    }
 
1351
    
 
1352
    uint16_t port;
 
1353
    errno = 0;
 
1354
    tmpmax = strtoimax(address+1, &tmp, 10);
 
1355
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
 
1356
       or tmpmax != (uint16_t)tmpmax){
 
1357
      fprintf(stderr, "Bad port number\n");
 
1358
      exitcode = EXIT_FAILURE;
 
1359
      goto end;
 
1360
    }
 
1361
  
 
1362
    if(quit_now){
 
1363
      goto end;
 
1364
    }
 
1365
    
 
1366
    port = (uint16_t)tmpmax;
 
1367
    *address = '\0';
 
1368
    address = connect_to;
 
1369
    /* Colon in address indicates IPv6 */
 
1370
    int af;
 
1371
    if(strchr(address, ':') != NULL){
 
1372
      af = AF_INET6;
 
1373
    } else {
 
1374
      af = AF_INET;
 
1375
    }
 
1376
    
 
1377
    if(quit_now){
 
1378
      goto end;
 
1379
    }
 
1380
    
 
1381
    ret = start_mandos_communication(address, port, if_index, af);
 
1382
    if(ret < 0){
 
1383
      exitcode = EXIT_FAILURE;
 
1384
    } else {
 
1385
      exitcode = EXIT_SUCCESS;
 
1386
    }
 
1387
    goto end;
 
1388
  }
 
1389
  
 
1390
  if(quit_now){
 
1391
    goto end;
 
1392
  }
 
1393
  
 
1394
  {
 
1395
    AvahiServerConfig config;
 
1396
    /* Do not publish any local Zeroconf records */
 
1397
    avahi_server_config_init(&config);
 
1398
    config.publish_hinfo = 0;
 
1399
    config.publish_addresses = 0;
 
1400
    config.publish_workstation = 0;
 
1401
    config.publish_domain = 0;
 
1402
    
 
1403
    /* Allocate a new server */
 
1404
    mc.server = avahi_server_new(avahi_simple_poll_get
 
1405
                                 (mc.simple_poll), &config, NULL,
 
1406
                                 NULL, &error);
 
1407
    
 
1408
    /* Free the Avahi configuration data */
 
1409
    avahi_server_config_free(&config);
 
1410
  }
 
1411
  
 
1412
  /* Check if creating the Avahi server object succeeded */
 
1413
  if(mc.server == NULL){
 
1414
    fprintf(stderr, "Failed to create Avahi server: %s\n",
 
1415
            avahi_strerror(error));
 
1416
    exitcode = EXIT_FAILURE;
 
1417
    goto end;
 
1418
  }
 
1419
  
 
1420
  if(quit_now){
 
1421
    goto end;
 
1422
  }
 
1423
  
 
1424
  /* Create the Avahi service browser */
 
1425
  sb = avahi_s_service_browser_new(mc.server, if_index,
 
1426
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
 
1427
                                   NULL, 0, browse_callback, NULL);
 
1428
  if(sb == NULL){
 
1429
    fprintf(stderr, "Failed to create service browser: %s\n",
 
1430
            avahi_strerror(avahi_server_errno(mc.server)));
 
1431
    exitcode = EXIT_FAILURE;
 
1432
    goto end;
 
1433
  }
 
1434
  
 
1435
  if(quit_now){
 
1436
    goto end;
 
1437
  }
 
1438
  
 
1439
  /* Run the main loop */
 
1440
  
 
1441
  if(debug){
 
1442
    fprintf(stderr, "Starting Avahi loop search\n");
 
1443
  }
 
1444
  
 
1445
  avahi_simple_poll_loop(mc.simple_poll);
 
1446
  
 
1447
 end:
 
1448
  
 
1449
  if(debug){
 
1450
    fprintf(stderr, "%s exiting\n", argv[0]);
 
1451
  }
 
1452
  
 
1453
  /* Cleanup things */
 
1454
  if(sb != NULL)
 
1455
    avahi_s_service_browser_free(sb);
 
1456
  
 
1457
  if(mc.server != NULL)
 
1458
    avahi_server_free(mc.server);
 
1459
  
 
1460
  if(mc.simple_poll != NULL)
 
1461
    avahi_simple_poll_free(mc.simple_poll);
 
1462
  
 
1463
  if(gnutls_initialized){
 
1464
    gnutls_certificate_free_credentials(mc.cred);
 
1465
    gnutls_global_deinit();
 
1466
    gnutls_dh_params_deinit(mc.dh_params);
 
1467
  }
 
1468
  
 
1469
  if(gpgme_initialized){
 
1470
    gpgme_release(mc.ctx);
 
1471
  }
 
1472
  
 
1473
  /* Take down the network interface */
 
1474
  if(take_down_interface){
 
1475
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1476
    if(ret == -1){
 
1477
      perror("ioctl SIOCGIFFLAGS");
 
1478
    } else if(network.ifr_flags & IFF_UP) {
 
1479
      network.ifr_flags &= ~IFF_UP; /* clear flag */
 
1480
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1481
      if(ret == -1){
 
1482
        perror("ioctl SIOCSIFFLAGS");
 
1483
      }
 
1484
    }
 
1485
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1486
    if(ret == -1){
 
1487
      perror("close");
 
1488
    }
 
1489
  }
 
1490
  
 
1491
  /* Removes the temp directory used by GPGME */
 
1492
  if(tempdir_created){
 
1493
    DIR *d;
 
1494
    struct dirent *direntry;
 
1495
    d = opendir(tempdir);
 
1496
    if(d == NULL){
 
1497
      if(errno != ENOENT){
 
1498
        perror("opendir");
 
1499
      }
 
1500
    } else {
 
1501
      while(true){
 
1502
        direntry = readdir(d);
 
1503
        if(direntry == NULL){
 
1504
          break;
 
1505
        }
 
1506
        /* Skip "." and ".." */
 
1507
        if(direntry->d_name[0] == '.'
 
1508
           and (direntry->d_name[1] == '\0'
 
1509
                or (direntry->d_name[1] == '.'
 
1510
                    and direntry->d_name[2] == '\0'))){
 
1511
          continue;
 
1512
        }
 
1513
        char *fullname = NULL;
 
1514
        ret = asprintf(&fullname, "%s/%s", tempdir,
 
1515
                       direntry->d_name);
 
1516
        if(ret < 0){
 
1517
          perror("asprintf");
 
1518
          continue;
 
1519
        }
 
1520
        ret = remove(fullname);
 
1521
        if(ret == -1){
 
1522
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
 
1523
                  strerror(errno));
 
1524
        }
 
1525
        free(fullname);
 
1526
      }
 
1527
      closedir(d);
 
1528
    }
 
1529
    ret = rmdir(tempdir);
 
1530
    if(ret == -1 and errno != ENOENT){
 
1531
      perror("rmdir");
 
1532
    }
 
1533
  }
 
1534
  
 
1535
  if(quit_now){
 
1536
    sigemptyset(&old_sigterm_action.sa_mask);
 
1537
    old_sigterm_action.sa_handler = SIG_DFL;
 
1538
    ret = sigaction(signal_received, &old_sigterm_action, NULL);
 
1539
    if(ret == -1){
 
1540
      perror("sigaction");
 
1541
    }
 
1542
    raise(signal_received);
 
1543
  }
 
1544
  
 
1545
  return exitcode;
 
1546
}