/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: 2011-07-13 02:24:39 UTC
  • mfrom: (24.1.174 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20110713022439-wbv6kghshdsc2x24
Merge from Björn.

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-2011 Teddy Hogeborn
 
13
 * Copyright © 2008-2011 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, srand(),
 
47
                                   strtof(), abort() */
 
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
                                   program_invocation_short_name */
 
67
#include <time.h>               /* nanosleep(), time(), sleep() */
 
68
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
 
69
                                   SIOCSIFFLAGS, if_indextoname(),
 
70
                                   if_nametoindex(), IF_NAMESIZE */
 
71
#include <netinet/in.h>         /* IN6_IS_ADDR_LINKLOCAL,
 
72
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
 
73
                                */
 
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
 
75
                                   getuid(), getgid(), seteuid(),
 
76
                                   setgid(), pause() */
 
77
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
78
#include <iso646.h>             /* not, or, and */
 
79
#include <argp.h>               /* struct argp_option, error_t, struct
 
80
                                   argp_state, struct argp,
 
81
                                   argp_parse(), ARGP_KEY_ARG,
 
82
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
 
83
#include <signal.h>             /* sigemptyset(), sigaddset(),
 
84
                                   sigaction(), SIGTERM, sig_atomic_t,
 
85
                                   raise() */
 
86
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
87
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
 
88
 
 
89
#ifdef __linux__
 
90
#include <sys/klog.h>           /* klogctl() */
 
91
#endif  /* __linux__ */
 
92
 
 
93
/* Avahi */
 
94
/* All Avahi types, constants and functions
 
95
 Avahi*, avahi_*,
 
96
 AVAHI_* */
 
97
#include <avahi-core/core.h>
 
98
#include <avahi-core/lookup.h>
 
99
#include <avahi-core/log.h>
 
100
#include <avahi-common/simple-watch.h>
 
101
#include <avahi-common/malloc.h>
 
102
#include <avahi-common/error.h>
 
103
 
 
104
/* GnuTLS */
 
105
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
 
106
                                   functions:
 
107
                                   gnutls_*
 
108
                                   init_gnutls_session(),
 
109
                                   GNUTLS_* */
 
110
#include <gnutls/openpgp.h>
 
111
                          /* gnutls_certificate_set_openpgp_key_file(),
 
112
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
113
 
 
114
/* GPGME */
 
115
#include <gpgme.h>              /* All GPGME types, constants and
 
116
                                   functions:
 
117
                                   gpgme_*
 
118
                                   GPGME_PROTOCOL_OpenPGP,
 
119
                                   GPG_ERR_NO_* */
 
120
 
 
121
#define BUFFER_SIZE 256
 
122
 
 
123
#define PATHDIR "/conf/conf.d/mandos"
 
124
#define SECKEY "seckey.txt"
 
125
#define PUBKEY "pubkey.txt"
 
126
 
 
127
bool debug = false;
 
128
static const char mandos_protocol_version[] = "1";
 
129
const char *argp_program_version = "mandos-client " VERSION;
 
130
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
131
static const char sys_class_net[] = "/sys/class/net";
 
132
char *connect_to = NULL;
 
133
 
 
134
/* Doubly linked list that need to be circularly linked when used */
 
135
typedef struct server{
 
136
  const char *ip;
 
137
  uint16_t port;
 
138
  AvahiIfIndex if_index;
 
139
  int af;
 
140
  struct timespec last_seen;
 
141
  struct server *next;
 
142
  struct server *prev;
 
143
} server;
 
144
 
 
145
/* Used for passing in values through the Avahi callback functions */
 
146
typedef struct {
 
147
  AvahiSimplePoll *simple_poll;
 
148
  AvahiServer *server;
 
149
  gnutls_certificate_credentials_t cred;
 
150
  unsigned int dh_bits;
 
151
  gnutls_dh_params_t dh_params;
 
152
  const char *priority;
 
153
  gpgme_ctx_t ctx;
 
154
  server *current_server;
 
155
} mandos_context;
 
156
 
 
157
/* global context so signal handler can reach it*/
 
158
mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
159
                      .dh_bits = 1024, .priority = "SECURE256"
 
160
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
 
161
                      .current_server = NULL };
 
162
 
 
163
sig_atomic_t quit_now = 0;
 
164
int signal_received = 0;
 
165
 
 
166
/* Function to use when printing errors */
 
167
void perror_plus(const char *print_text){
 
168
  fprintf(stderr, "Mandos plugin %s: ",
 
169
          program_invocation_short_name);
 
170
  perror(print_text);
 
171
}
 
172
 
 
173
/*
 
174
 * Make additional room in "buffer" for at least BUFFER_SIZE more
 
175
 * bytes. "buffer_capacity" is how much is currently allocated,
 
176
 * "buffer_length" is how much is already used.
 
177
 */
 
178
size_t incbuffer(char **buffer, size_t buffer_length,
 
179
                  size_t buffer_capacity){
 
180
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
 
181
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
182
    if(buffer == NULL){
 
183
      return 0;
 
184
    }
 
185
    buffer_capacity += BUFFER_SIZE;
 
186
  }
 
187
  return buffer_capacity;
 
188
}
 
189
 
 
190
int add_server(const char *ip, uint16_t port,
 
191
                 AvahiIfIndex if_index,
 
192
                 int af){
 
193
  int ret;
 
194
  server *new_server = malloc(sizeof(server));
 
195
  if(new_server == NULL){
 
196
    perror_plus("malloc");
 
197
    return -1;
 
198
  }
 
199
  *new_server = (server){ .ip = strdup(ip),
 
200
                         .port = port,
 
201
                         .if_index = if_index,
 
202
                         .af = af };
 
203
  if(new_server->ip == NULL){
 
204
    perror_plus("strdup");
 
205
    return -1;
 
206
  }
 
207
  /* unique case of first server */
 
208
  if (mc.current_server == NULL){
 
209
    new_server->next = new_server;
 
210
    new_server->prev = new_server;
 
211
    mc.current_server = new_server;
 
212
  /* Placing the new server last in the list */
 
213
  } else {
 
214
    new_server->next = mc.current_server;
 
215
    new_server->prev = mc.current_server->prev;
 
216
    new_server->prev->next = new_server;
 
217
    mc.current_server->prev = new_server;
 
218
  }
 
219
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
 
220
  if(ret == -1){
 
221
    perror_plus("clock_gettime");
 
222
    return -1;
 
223
  }
 
224
  return 0;
 
225
}
 
226
 
 
227
/* 
 
228
 * Initialize GPGME.
 
229
 */
 
230
static bool init_gpgme(const char *seckey,
 
231
                       const char *pubkey, const char *tempdir){
 
232
  gpgme_error_t rc;
 
233
  gpgme_engine_info_t engine_info;
 
234
  
 
235
  
 
236
  /*
 
237
   * Helper function to insert pub and seckey to the engine keyring.
 
238
   */
 
239
  bool import_key(const char *filename){
 
240
    int ret;
 
241
    int fd;
 
242
    gpgme_data_t pgp_data;
 
243
    
 
244
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
245
    if(fd == -1){
 
246
      perror_plus("open");
 
247
      return false;
 
248
    }
 
249
    
 
250
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
251
    if(rc != GPG_ERR_NO_ERROR){
 
252
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
253
              gpgme_strsource(rc), gpgme_strerror(rc));
 
254
      return false;
 
255
    }
 
256
    
 
257
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
258
    if(rc != GPG_ERR_NO_ERROR){
 
259
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
 
260
              gpgme_strsource(rc), gpgme_strerror(rc));
 
261
      return false;
 
262
    }
 
263
    
 
264
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
265
    if(ret == -1){
 
266
      perror_plus("close");
 
267
    }
 
268
    gpgme_data_release(pgp_data);
 
269
    return true;
 
270
  }
 
271
  
 
272
  if(debug){
 
273
    fprintf(stderr, "Initializing GPGME\n");
 
274
  }
 
275
  
 
276
  /* Init GPGME */
 
277
  gpgme_check_version(NULL);
 
278
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
279
  if(rc != GPG_ERR_NO_ERROR){
 
280
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
281
            gpgme_strsource(rc), gpgme_strerror(rc));
 
282
    return false;
 
283
  }
 
284
  
 
285
    /* Set GPGME home directory for the OpenPGP engine only */
 
286
  rc = gpgme_get_engine_info(&engine_info);
 
287
  if(rc != GPG_ERR_NO_ERROR){
 
288
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
289
            gpgme_strsource(rc), gpgme_strerror(rc));
 
290
    return false;
 
291
  }
 
292
  while(engine_info != NULL){
 
293
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
 
294
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
 
295
                            engine_info->file_name, tempdir);
 
296
      break;
 
297
    }
 
298
    engine_info = engine_info->next;
 
299
  }
 
300
  if(engine_info == NULL){
 
301
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
302
    return false;
 
303
  }
 
304
  
 
305
  /* Create new GPGME "context" */
 
306
  rc = gpgme_new(&(mc.ctx));
 
307
  if(rc != GPG_ERR_NO_ERROR){
 
308
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
309
            gpgme_strsource(rc), gpgme_strerror(rc));
 
310
    return false;
 
311
  }
 
312
  
 
313
  if(not import_key(pubkey) or not import_key(seckey)){
 
314
    return false;
 
315
  }
 
316
  
 
317
  return true;
 
318
}
 
319
 
 
320
/* 
 
321
 * Decrypt OpenPGP data.
 
322
 * Returns -1 on error
 
323
 */
 
324
static ssize_t pgp_packet_decrypt(const char *cryptotext,
 
325
                                  size_t crypto_size,
 
326
                                  char **plaintext){
 
327
  gpgme_data_t dh_crypto, dh_plain;
 
328
  gpgme_error_t rc;
 
329
  ssize_t ret;
 
330
  size_t plaintext_capacity = 0;
 
331
  ssize_t plaintext_length = 0;
 
332
  
 
333
  if(debug){
 
334
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
335
  }
 
336
  
 
337
  /* Create new GPGME data buffer from memory cryptotext */
 
338
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
339
                               0);
 
340
  if(rc != GPG_ERR_NO_ERROR){
 
341
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
342
            gpgme_strsource(rc), gpgme_strerror(rc));
 
343
    return -1;
 
344
  }
 
345
  
 
346
  /* Create new empty GPGME data buffer for the plaintext */
 
347
  rc = gpgme_data_new(&dh_plain);
 
348
  if(rc != GPG_ERR_NO_ERROR){
 
349
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
350
            gpgme_strsource(rc), gpgme_strerror(rc));
 
351
    gpgme_data_release(dh_crypto);
 
352
    return -1;
 
353
  }
 
354
  
 
355
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
356
     data buffer */
 
357
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
358
  if(rc != GPG_ERR_NO_ERROR){
 
359
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
360
            gpgme_strsource(rc), gpgme_strerror(rc));
 
361
    plaintext_length = -1;
 
362
    if(debug){
 
363
      gpgme_decrypt_result_t result;
 
364
      result = gpgme_op_decrypt_result(mc.ctx);
 
365
      if(result == NULL){
 
366
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
367
      } else {
 
368
        fprintf(stderr, "Unsupported algorithm: %s\n",
 
369
                result->unsupported_algorithm);
 
370
        fprintf(stderr, "Wrong key usage: %u\n",
 
371
                result->wrong_key_usage);
 
372
        if(result->file_name != NULL){
 
373
          fprintf(stderr, "File name: %s\n", result->file_name);
 
374
        }
 
375
        gpgme_recipient_t recipient;
 
376
        recipient = result->recipients;
 
377
        while(recipient != NULL){
 
378
          fprintf(stderr, "Public key algorithm: %s\n",
 
379
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
380
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
381
          fprintf(stderr, "Secret key available: %s\n",
 
382
                  recipient->status == GPG_ERR_NO_SECKEY
 
383
                  ? "No" : "Yes");
 
384
          recipient = recipient->next;
 
385
        }
 
386
      }
 
387
    }
 
388
    goto decrypt_end;
 
389
  }
 
390
  
 
391
  if(debug){
 
392
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
393
  }
 
394
  
 
395
  /* Seek back to the beginning of the GPGME plaintext data buffer */
 
396
  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
 
397
    perror_plus("gpgme_data_seek");
 
398
    plaintext_length = -1;
 
399
    goto decrypt_end;
 
400
  }
 
401
  
 
402
  *plaintext = NULL;
 
403
  while(true){
 
404
    plaintext_capacity = incbuffer(plaintext,
 
405
                                      (size_t)plaintext_length,
 
406
                                      plaintext_capacity);
 
407
    if(plaintext_capacity == 0){
 
408
        perror_plus("incbuffer");
 
409
        plaintext_length = -1;
 
410
        goto decrypt_end;
 
411
    }
 
412
    
 
413
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
414
                          BUFFER_SIZE);
 
415
    /* Print the data, if any */
 
416
    if(ret == 0){
 
417
      /* EOF */
 
418
      break;
 
419
    }
 
420
    if(ret < 0){
 
421
      perror_plus("gpgme_data_read");
 
422
      plaintext_length = -1;
 
423
      goto decrypt_end;
 
424
    }
 
425
    plaintext_length += ret;
 
426
  }
 
427
  
 
428
  if(debug){
 
429
    fprintf(stderr, "Decrypted password is: ");
 
430
    for(ssize_t i = 0; i < plaintext_length; i++){
 
431
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
 
432
    }
 
433
    fprintf(stderr, "\n");
 
434
  }
 
435
  
 
436
 decrypt_end:
 
437
  
 
438
  /* Delete the GPGME cryptotext data buffer */
 
439
  gpgme_data_release(dh_crypto);
 
440
  
 
441
  /* Delete the GPGME plaintext data buffer */
 
442
  gpgme_data_release(dh_plain);
 
443
  return plaintext_length;
 
444
}
 
445
 
 
446
static const char * safer_gnutls_strerror(int value){
 
447
  const char *ret = gnutls_strerror(value); /* Spurious warning from
 
448
                                               -Wunreachable-code */
 
449
  if(ret == NULL)
 
450
    ret = "(unknown)";
 
451
  return ret;
 
452
}
 
453
 
 
454
/* GnuTLS log function callback */
 
455
static void debuggnutls(__attribute__((unused)) int level,
 
456
                        const char* string){
 
457
  fprintf(stderr, "GnuTLS: %s", string);
 
458
}
 
459
 
 
460
static int init_gnutls_global(const char *pubkeyfilename,
 
461
                              const char *seckeyfilename){
 
462
  int ret;
 
463
  
 
464
  if(debug){
 
465
    fprintf(stderr, "Initializing GnuTLS\n");
 
466
  }
 
467
  
 
468
  ret = gnutls_global_init();
 
469
  if(ret != GNUTLS_E_SUCCESS){
 
470
    fprintf(stderr, "GnuTLS global_init: %s\n",
 
471
            safer_gnutls_strerror(ret));
 
472
    return -1;
 
473
  }
 
474
  
 
475
  if(debug){
 
476
    /* "Use a log level over 10 to enable all debugging options."
 
477
     * - GnuTLS manual
 
478
     */
 
479
    gnutls_global_set_log_level(11);
 
480
    gnutls_global_set_log_function(debuggnutls);
 
481
  }
 
482
  
 
483
  /* OpenPGP credentials */
 
484
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
485
  if(ret != GNUTLS_E_SUCCESS){
 
486
    fprintf(stderr, "GnuTLS memory error: %s\n",
 
487
            safer_gnutls_strerror(ret));
 
488
    gnutls_global_deinit();
 
489
    return -1;
 
490
  }
 
491
  
 
492
  if(debug){
 
493
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
494
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
 
495
            seckeyfilename);
 
496
  }
 
497
  
 
498
  ret = gnutls_certificate_set_openpgp_key_file
 
499
    (mc.cred, pubkeyfilename, seckeyfilename,
 
500
     GNUTLS_OPENPGP_FMT_BASE64);
 
501
  if(ret != GNUTLS_E_SUCCESS){
 
502
    fprintf(stderr,
 
503
            "Error[%d] while reading the OpenPGP key pair ('%s',"
 
504
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
505
    fprintf(stderr, "The GnuTLS error is: %s\n",
 
506
            safer_gnutls_strerror(ret));
 
507
    goto globalfail;
 
508
  }
 
509
  
 
510
  /* GnuTLS server initialization */
 
511
  ret = gnutls_dh_params_init(&mc.dh_params);
 
512
  if(ret != GNUTLS_E_SUCCESS){
 
513
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
 
514
            " %s\n", safer_gnutls_strerror(ret));
 
515
    goto globalfail;
 
516
  }
 
517
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
518
  if(ret != GNUTLS_E_SUCCESS){
 
519
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
 
520
            safer_gnutls_strerror(ret));
 
521
    goto globalfail;
 
522
  }
 
523
  
 
524
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
525
  
 
526
  return 0;
 
527
  
 
528
 globalfail:
 
529
  
 
530
  gnutls_certificate_free_credentials(mc.cred);
 
531
  gnutls_global_deinit();
 
532
  gnutls_dh_params_deinit(mc.dh_params);
 
533
  return -1;
 
534
}
 
535
 
 
536
static int init_gnutls_session(gnutls_session_t *session){
 
537
  int ret;
 
538
  /* GnuTLS session creation */
 
539
  do {
 
540
    ret = gnutls_init(session, GNUTLS_SERVER);
 
541
    if(quit_now){
 
542
      return -1;
 
543
    }
 
544
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
545
  if(ret != GNUTLS_E_SUCCESS){
 
546
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
 
547
            safer_gnutls_strerror(ret));
 
548
  }
 
549
  
 
550
  {
 
551
    const char *err;
 
552
    do {
 
553
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
554
      if(quit_now){
 
555
        gnutls_deinit(*session);
 
556
        return -1;
 
557
      }
 
558
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
559
    if(ret != GNUTLS_E_SUCCESS){
 
560
      fprintf(stderr, "Syntax error at: %s\n", err);
 
561
      fprintf(stderr, "GnuTLS error: %s\n",
 
562
              safer_gnutls_strerror(ret));
 
563
      gnutls_deinit(*session);
 
564
      return -1;
 
565
    }
 
566
  }
 
567
  
 
568
  do {
 
569
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
570
                                 mc.cred);
 
571
    if(quit_now){
 
572
      gnutls_deinit(*session);
 
573
      return -1;
 
574
    }
 
575
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
576
  if(ret != GNUTLS_E_SUCCESS){
 
577
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
 
578
            safer_gnutls_strerror(ret));
 
579
    gnutls_deinit(*session);
 
580
    return -1;
 
581
  }
 
582
  
 
583
  /* ignore client certificate if any. */
 
584
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
 
585
  
 
586
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
587
  
 
588
  return 0;
 
589
}
 
590
 
 
591
/* Avahi log function callback */
 
592
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
593
                      __attribute__((unused)) const char *txt){}
 
594
 
 
595
/* Called when a Mandos server is found */
 
596
static int start_mandos_communication(const char *ip, uint16_t port,
 
597
                                      AvahiIfIndex if_index,
 
598
                                      int af){
 
599
  int ret, tcp_sd = -1;
 
600
  ssize_t sret;
 
601
  union {
 
602
    struct sockaddr_in in;
 
603
    struct sockaddr_in6 in6;
 
604
  } to;
 
605
  char *buffer = NULL;
 
606
  char *decrypted_buffer = NULL;
 
607
  size_t buffer_length = 0;
 
608
  size_t buffer_capacity = 0;
 
609
  size_t written;
 
610
  int retval = -1;
 
611
  gnutls_session_t session;
 
612
  int pf;                       /* Protocol family */
 
613
  
 
614
  errno = 0;
 
615
  
 
616
  if(quit_now){
 
617
    errno = EINTR;
 
618
    return -1;
 
619
  }
 
620
  
 
621
  switch(af){
 
622
  case AF_INET6:
 
623
    pf = PF_INET6;
 
624
    break;
 
625
  case AF_INET:
 
626
    pf = PF_INET;
 
627
    break;
 
628
  default:
 
629
    fprintf(stderr, "Bad address family: %d\n", af);
 
630
    errno = EINVAL;
 
631
    return -1;
 
632
  }
 
633
  
 
634
  ret = init_gnutls_session(&session);
 
635
  if(ret != 0){
 
636
    return -1;
 
637
  }
 
638
  
 
639
  if(debug){
 
640
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
 
641
            "\n", ip, port);
 
642
  }
 
643
  
 
644
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
645
  if(tcp_sd < 0){
 
646
    int e = errno;
 
647
    perror_plus("socket");
 
648
    errno = e;
 
649
    goto mandos_end;
 
650
  }
 
651
  
 
652
  if(quit_now){
 
653
    errno = EINTR;
 
654
    goto mandos_end;
 
655
  }
 
656
  
 
657
  memset(&to, 0, sizeof(to));
 
658
  if(af == AF_INET6){
 
659
    to.in6.sin6_family = (sa_family_t)af;
 
660
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
661
  } else {                      /* IPv4 */
 
662
    to.in.sin_family = (sa_family_t)af;
 
663
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
664
  }
 
665
  if(ret < 0 ){
 
666
    int e = errno;
 
667
    perror_plus("inet_pton");
 
668
    errno = e;
 
669
    goto mandos_end;
 
670
  }
 
671
  if(ret == 0){
 
672
    int e = errno;
 
673
    fprintf(stderr, "Bad address: %s\n", ip);
 
674
    errno = e;
 
675
    goto mandos_end;
 
676
  }
 
677
  if(af == AF_INET6){
 
678
    to.in6.sin6_port = htons(port); /* Spurious warnings from
 
679
                                       -Wconversion and
 
680
                                       -Wunreachable-code */
 
681
    
 
682
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
 
683
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
 
684
                              -Wunreachable-code*/
 
685
      if(if_index == AVAHI_IF_UNSPEC){
 
686
        fprintf(stderr, "An IPv6 link-local address is incomplete"
 
687
                " without a network interface\n");
 
688
        errno = EINVAL;
 
689
        goto mandos_end;
 
690
      }
 
691
      /* Set the network interface number as scope */
 
692
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
693
    }
 
694
  } else {
 
695
    to.in.sin_port = htons(port); /* Spurious warnings from
 
696
                                     -Wconversion and
 
697
                                     -Wunreachable-code */
 
698
  }
 
699
  
 
700
  if(quit_now){
 
701
    errno = EINTR;
 
702
    goto mandos_end;
 
703
  }
 
704
  
 
705
  if(debug){
 
706
    if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
 
707
      char interface[IF_NAMESIZE];
 
708
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
709
        perror_plus("if_indextoname");
 
710
      } else {
 
711
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
 
712
                ip, interface, port);
 
713
      }
 
714
    } else {
 
715
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
 
716
              port);
 
717
    }
 
718
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
 
719
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
 
720
    const char *pcret;
 
721
    if(af == AF_INET6){
 
722
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
 
723
                        sizeof(addrstr));
 
724
    } else {
 
725
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
 
726
                        sizeof(addrstr));
 
727
    }
 
728
    if(pcret == NULL){
 
729
      perror_plus("inet_ntop");
 
730
    } else {
 
731
      if(strcmp(addrstr, ip) != 0){
 
732
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
 
733
      }
 
734
    }
 
735
  }
 
736
  
 
737
  if(quit_now){
 
738
    errno = EINTR;
 
739
    goto mandos_end;
 
740
  }
 
741
  
 
742
  if(af == AF_INET6){
 
743
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
744
  } else {
 
745
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
746
  }
 
747
  if(ret < 0){
 
748
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
749
      int e = errno;
 
750
      perror_plus("connect");
 
751
      errno = e;
 
752
    }
 
753
    goto mandos_end;
 
754
  }
 
755
  
 
756
  if(quit_now){
 
757
    errno = EINTR;
 
758
    goto mandos_end;
 
759
  }
 
760
  
 
761
  const char *out = mandos_protocol_version;
 
762
  written = 0;
 
763
  while(true){
 
764
    size_t out_size = strlen(out);
 
765
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
 
766
                                   out_size - written));
 
767
    if(ret == -1){
 
768
      int e = errno;
 
769
      perror_plus("write");
 
770
      errno = e;
 
771
      goto mandos_end;
 
772
    }
 
773
    written += (size_t)ret;
 
774
    if(written < out_size){
 
775
      continue;
 
776
    } else {
 
777
      if(out == mandos_protocol_version){
 
778
        written = 0;
 
779
        out = "\r\n";
 
780
      } else {
 
781
        break;
 
782
      }
 
783
    }
 
784
  
 
785
    if(quit_now){
 
786
      errno = EINTR;
 
787
      goto mandos_end;
 
788
    }
 
789
  }
 
790
  
 
791
  if(debug){
 
792
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
793
  }
 
794
  
 
795
  if(quit_now){
 
796
    errno = EINTR;
 
797
    goto mandos_end;
 
798
  }
 
799
  
 
800
  /* Spurious warning from -Wint-to-pointer-cast */
 
801
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
802
  
 
803
  if(quit_now){
 
804
    errno = EINTR;
 
805
    goto mandos_end;
 
806
  }
 
807
  
 
808
  do {
 
809
    ret = gnutls_handshake(session);
 
810
    if(quit_now){
 
811
      errno = EINTR;
 
812
      goto mandos_end;
 
813
    }
 
814
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
815
  
 
816
  if(ret != GNUTLS_E_SUCCESS){
 
817
    if(debug){
 
818
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
819
      gnutls_perror(ret);
 
820
    }
 
821
    errno = EPROTO;
 
822
    goto mandos_end;
 
823
  }
 
824
  
 
825
  /* Read OpenPGP packet that contains the wanted password */
 
826
  
 
827
  if(debug){
 
828
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
 
829
            ip);
 
830
  }
 
831
  
 
832
  while(true){
 
833
    
 
834
    if(quit_now){
 
835
      errno = EINTR;
 
836
      goto mandos_end;
 
837
    }
 
838
    
 
839
    buffer_capacity = incbuffer(&buffer, buffer_length,
 
840
                                   buffer_capacity);
 
841
    if(buffer_capacity == 0){
 
842
      int e = errno;
 
843
      perror_plus("incbuffer");
 
844
      errno = e;
 
845
      goto mandos_end;
 
846
    }
 
847
    
 
848
    if(quit_now){
 
849
      errno = EINTR;
 
850
      goto mandos_end;
 
851
    }
 
852
    
 
853
    sret = gnutls_record_recv(session, buffer+buffer_length,
 
854
                              BUFFER_SIZE);
 
855
    if(sret == 0){
 
856
      break;
 
857
    }
 
858
    if(sret < 0){
 
859
      switch(sret){
 
860
      case GNUTLS_E_INTERRUPTED:
 
861
      case GNUTLS_E_AGAIN:
 
862
        break;
 
863
      case GNUTLS_E_REHANDSHAKE:
 
864
        do {
 
865
          ret = gnutls_handshake(session);
 
866
          
 
867
          if(quit_now){
 
868
            errno = EINTR;
 
869
            goto mandos_end;
 
870
          }
 
871
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
872
        if(ret < 0){
 
873
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
874
          gnutls_perror(ret);
 
875
          errno = EPROTO;
 
876
          goto mandos_end;
 
877
        }
 
878
        break;
 
879
      default:
 
880
        fprintf(stderr, "Unknown error while reading data from"
 
881
                " encrypted session with Mandos server\n");
 
882
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
883
        errno = EIO;
 
884
        goto mandos_end;
 
885
      }
 
886
    } else {
 
887
      buffer_length += (size_t) sret;
 
888
    }
 
889
  }
 
890
  
 
891
  if(debug){
 
892
    fprintf(stderr, "Closing TLS session\n");
 
893
  }
 
894
  
 
895
  if(quit_now){
 
896
    errno = EINTR;
 
897
    goto mandos_end;
 
898
  }
 
899
  
 
900
  do {
 
901
    ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
902
    if(quit_now){
 
903
      errno = EINTR;
 
904
      goto mandos_end;
 
905
    }
 
906
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
907
  
 
908
  if(buffer_length > 0){
 
909
    ssize_t decrypted_buffer_size;
 
910
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
911
                                               buffer_length,
 
912
                                               &decrypted_buffer);
 
913
    if(decrypted_buffer_size >= 0){
 
914
      
 
915
      written = 0;
 
916
      while(written < (size_t) decrypted_buffer_size){
 
917
        if(quit_now){
 
918
          errno = EINTR;
 
919
          goto mandos_end;
 
920
        }
 
921
        
 
922
        ret = (int)fwrite(decrypted_buffer + written, 1,
 
923
                          (size_t)decrypted_buffer_size - written,
 
924
                          stdout);
 
925
        if(ret == 0 and ferror(stdout)){
 
926
          int e = errno;
 
927
          if(debug){
 
928
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
929
                    strerror(errno));
 
930
          }
 
931
          errno = e;
 
932
          goto mandos_end;
 
933
        }
 
934
        written += (size_t)ret;
 
935
      }
 
936
      retval = 0;
 
937
    }
 
938
  }
 
939
  
 
940
  /* Shutdown procedure */
 
941
  
 
942
 mandos_end:
 
943
  {
 
944
    int e = errno;
 
945
    free(decrypted_buffer);
 
946
    free(buffer);
 
947
    if(tcp_sd >= 0){
 
948
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
949
    }
 
950
    if(ret == -1){
 
951
      if(e == 0){
 
952
        e = errno;
 
953
      }
 
954
      perror_plus("close");
 
955
    }
 
956
    gnutls_deinit(session);
 
957
    errno = e;
 
958
    if(quit_now){
 
959
      errno = EINTR;
 
960
      retval = -1;
 
961
    }
 
962
  }
 
963
  return retval;
 
964
}
 
965
 
 
966
static void resolve_callback(AvahiSServiceResolver *r,
 
967
                             AvahiIfIndex interface,
 
968
                             AvahiProtocol proto,
 
969
                             AvahiResolverEvent event,
 
970
                             const char *name,
 
971
                             const char *type,
 
972
                             const char *domain,
 
973
                             const char *host_name,
 
974
                             const AvahiAddress *address,
 
975
                             uint16_t port,
 
976
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
 
977
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
978
                             flags,
 
979
                             AVAHI_GCC_UNUSED void* userdata){
 
980
  assert(r);
 
981
  
 
982
  /* Called whenever a service has been resolved successfully or
 
983
     timed out */
 
984
  
 
985
  if(quit_now){
 
986
    return;
 
987
  }
 
988
  
 
989
  switch(event){
 
990
  default:
 
991
  case AVAHI_RESOLVER_FAILURE:
 
992
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
 
993
            " of type '%s' in domain '%s': %s\n", name, type, domain,
 
994
            avahi_strerror(avahi_server_errno(mc.server)));
 
995
    break;
 
996
    
 
997
  case AVAHI_RESOLVER_FOUND:
 
998
    {
 
999
      char ip[AVAHI_ADDRESS_STR_MAX];
 
1000
      avahi_address_snprint(ip, sizeof(ip), address);
 
1001
      if(debug){
 
1002
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
1003
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
 
1004
                ip, (intmax_t)interface, port);
 
1005
      }
 
1006
      int ret = start_mandos_communication(ip, port, interface,
 
1007
                                           avahi_proto_to_af(proto));
 
1008
      if(ret == 0){
 
1009
        avahi_simple_poll_quit(mc.simple_poll);
 
1010
      } else {
 
1011
        ret = add_server(ip, port, interface,
 
1012
                         avahi_proto_to_af(proto));
 
1013
      }
 
1014
    }
 
1015
  }
 
1016
  avahi_s_service_resolver_free(r);
 
1017
}
 
1018
 
 
1019
static void browse_callback(AvahiSServiceBrowser *b,
 
1020
                            AvahiIfIndex interface,
 
1021
                            AvahiProtocol protocol,
 
1022
                            AvahiBrowserEvent event,
 
1023
                            const char *name,
 
1024
                            const char *type,
 
1025
                            const char *domain,
 
1026
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
1027
                            flags,
 
1028
                            AVAHI_GCC_UNUSED void* userdata){
 
1029
  assert(b);
 
1030
  
 
1031
  /* Called whenever a new services becomes available on the LAN or
 
1032
     is removed from the LAN */
 
1033
  
 
1034
  if(quit_now){
 
1035
    return;
 
1036
  }
 
1037
  
 
1038
  switch(event){
 
1039
  default:
 
1040
  case AVAHI_BROWSER_FAILURE:
 
1041
    
 
1042
    fprintf(stderr, "(Avahi browser) %s\n",
 
1043
            avahi_strerror(avahi_server_errno(mc.server)));
 
1044
    avahi_simple_poll_quit(mc.simple_poll);
 
1045
    return;
 
1046
    
 
1047
  case AVAHI_BROWSER_NEW:
 
1048
    /* We ignore the returned Avahi resolver object. In the callback
 
1049
       function we free it. If the Avahi server is terminated before
 
1050
       the callback function is called the Avahi server will free the
 
1051
       resolver for us. */
 
1052
    
 
1053
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
 
1054
                                    name, type, domain, protocol, 0,
 
1055
                                    resolve_callback, NULL) == NULL)
 
1056
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
 
1057
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
1058
    break;
 
1059
    
 
1060
  case AVAHI_BROWSER_REMOVE:
 
1061
    break;
 
1062
    
 
1063
  case AVAHI_BROWSER_ALL_FOR_NOW:
 
1064
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
1065
    if(debug){
 
1066
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
1067
    }
 
1068
    break;
 
1069
  }
 
1070
}
 
1071
 
 
1072
/* Signal handler that stops main loop after SIGTERM */
 
1073
static void handle_sigterm(int sig){
 
1074
  if(quit_now){
 
1075
    return;
 
1076
  }
 
1077
  quit_now = 1;
 
1078
  signal_received = sig;
 
1079
  int old_errno = errno;
 
1080
  /* set main loop to exit */
 
1081
  if(mc.simple_poll != NULL){
 
1082
    avahi_simple_poll_quit(mc.simple_poll);
 
1083
  }
 
1084
  errno = old_errno;
 
1085
}
 
1086
 
 
1087
/* 
 
1088
 * This function determines if a directory entry in /sys/class/net
 
1089
 * corresponds to an acceptable network device.
 
1090
 * (This function is passed to scandir(3) as a filter function.)
 
1091
 */
 
1092
int good_interface(const struct dirent *if_entry){
 
1093
  ssize_t ssret;
 
1094
  char *flagname = NULL;
 
1095
  if(if_entry->d_name[0] == '.'){
 
1096
    return 0;
 
1097
  }
 
1098
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
 
1099
                     if_entry->d_name);
 
1100
  if(ret < 0){
 
1101
    perror_plus("asprintf");
 
1102
    return 0;
 
1103
  }
 
1104
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
 
1105
  if(flags_fd == -1){
 
1106
    perror_plus("open");
 
1107
    free(flagname);
 
1108
    return 0;
 
1109
  }
 
1110
  free(flagname);
 
1111
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
 
1112
  /* read line from flags_fd */
 
1113
  ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
 
1114
  char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
 
1115
  flagstring[(size_t)to_read] = '\0';
 
1116
  if(flagstring == NULL){
 
1117
    perror_plus("malloc");
 
1118
    close(flags_fd);
 
1119
    return 0;
 
1120
  }
 
1121
  while(to_read > 0){
 
1122
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
 
1123
                                             (size_t)to_read));
 
1124
    if(ssret == -1){
 
1125
      perror_plus("read");
 
1126
      free(flagstring);
 
1127
      close(flags_fd);
 
1128
      return 0;
 
1129
    }
 
1130
    to_read -= ssret;
 
1131
    if(ssret == 0){
 
1132
      break;
 
1133
    }
 
1134
  }
 
1135
  close(flags_fd);
 
1136
  intmax_t tmpmax;
 
1137
  char *tmp;
 
1138
  errno = 0;
 
1139
  tmpmax = strtoimax(flagstring, &tmp, 0);
 
1140
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
 
1141
                                         and not (isspace(*tmp)))
 
1142
     or tmpmax != (ifreq_flags)tmpmax){
 
1143
    if(debug){
 
1144
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
 
1145
              flagstring, if_entry->d_name);
 
1146
    }
 
1147
    free(flagstring);
 
1148
    return 0;
 
1149
  }
 
1150
  free(flagstring);
 
1151
  ifreq_flags flags = (ifreq_flags)tmpmax;
 
1152
  /* Reject the loopback device */
 
1153
  if(flags & IFF_LOOPBACK){
 
1154
    if(debug){
 
1155
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
 
1156
              if_entry->d_name);
 
1157
    }
 
1158
    return 0;
 
1159
  }
 
1160
  /* Accept point-to-point devices only if connect_to is specified */
 
1161
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
 
1162
    if(debug){
 
1163
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
 
1164
              if_entry->d_name);
 
1165
    }
 
1166
    return 1;
 
1167
  }
 
1168
  /* Otherwise, reject non-broadcast-capable devices */
 
1169
  if(not (flags & IFF_BROADCAST)){
 
1170
    if(debug){
 
1171
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
 
1172
              if_entry->d_name);
 
1173
    }
 
1174
    return 0;
 
1175
  }
 
1176
  /* Reject non-ARP interfaces (including dummy interfaces) */
 
1177
  if(flags & IFF_NOARP){
 
1178
    if(debug){
 
1179
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
 
1180
              if_entry->d_name);
 
1181
    }
 
1182
    return 0;
 
1183
  }
 
1184
  /* Accept this device */
 
1185
  if(debug){
 
1186
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
 
1187
            if_entry->d_name);
 
1188
  }
 
1189
  return 1;
 
1190
}
 
1191
 
 
1192
int notdotentries(const struct dirent *direntry){
 
1193
  /* Skip "." and ".." */
 
1194
  if(direntry->d_name[0] == '.'
 
1195
     and (direntry->d_name[1] == '\0'
 
1196
          or (direntry->d_name[1] == '.'
 
1197
              and direntry->d_name[2] == '\0'))){
 
1198
    return 0;
 
1199
  }
 
1200
  return 1;
 
1201
}
 
1202
 
 
1203
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1204
  int ret;
 
1205
  struct timespec now;
 
1206
  struct timespec waited_time;
 
1207
  intmax_t block_time;
 
1208
 
 
1209
  while(true){
 
1210
    if(mc.current_server == NULL){
 
1211
      if (debug){
 
1212
        fprintf(stderr,
 
1213
                "Wait until first server is found. No timeout!\n");
 
1214
      }
 
1215
      ret = avahi_simple_poll_iterate(s, -1);
 
1216
    } else {
 
1217
      if (debug){
 
1218
        fprintf(stderr, "Check current_server if we should run it,"
 
1219
                " or wait\n");
 
1220
      }
 
1221
      /* the current time */
 
1222
      ret = clock_gettime(CLOCK_MONOTONIC, &now);
 
1223
      if(ret == -1){
 
1224
        perror_plus("clock_gettime");
 
1225
        return -1;
 
1226
      }
 
1227
      /* Calculating in ms how long time between now and server
 
1228
         who we visted longest time ago. Now - last seen.  */
 
1229
      waited_time.tv_sec = (now.tv_sec
 
1230
                            - mc.current_server->last_seen.tv_sec);
 
1231
      waited_time.tv_nsec = (now.tv_nsec
 
1232
                             - mc.current_server->last_seen.tv_nsec);
 
1233
      /* total time is 10s/10,000ms.
 
1234
         Converting to s from ms by dividing by 1,000,
 
1235
         and ns to ms by dividing by 1,000,000. */
 
1236
      block_time = ((retry_interval
 
1237
                     - ((intmax_t)waited_time.tv_sec * 1000))
 
1238
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
 
1239
 
 
1240
      if (debug){
 
1241
        fprintf(stderr, "Blocking for %ld ms\n", block_time);
 
1242
      }
 
1243
 
 
1244
      if(block_time <= 0){
 
1245
        ret = start_mandos_communication(mc.current_server->ip,
 
1246
                                         mc.current_server->port,
 
1247
                                         mc.current_server->if_index,
 
1248
                                         mc.current_server->af);
 
1249
        if(ret == 0){
 
1250
          avahi_simple_poll_quit(mc.simple_poll);
 
1251
          return 0;
 
1252
        }
 
1253
        ret = clock_gettime(CLOCK_MONOTONIC,
 
1254
                            &mc.current_server->last_seen);
 
1255
        if(ret == -1){
 
1256
          perror_plus("clock_gettime");
 
1257
          return -1;
 
1258
        }
 
1259
        mc.current_server = mc.current_server->next;
 
1260
        block_time = 0;         /* Call avahi to find new Mandos
 
1261
                                   servers, but don't block */
 
1262
      }
 
1263
      
 
1264
      ret = avahi_simple_poll_iterate(s, (int)block_time);
 
1265
    }
 
1266
    if(ret != 0){
 
1267
      if (ret > 0 or errno != EINTR) {
 
1268
        return (ret != 1) ? ret : 0;
 
1269
      }
 
1270
    }
 
1271
  }
 
1272
}
 
1273
 
 
1274
int main(int argc, char *argv[]){
 
1275
  AvahiSServiceBrowser *sb = NULL;
 
1276
  int error;
 
1277
  int ret;
 
1278
  intmax_t tmpmax;
 
1279
  char *tmp;
 
1280
  int exitcode = EXIT_SUCCESS;
 
1281
  const char *interface = "";
 
1282
  struct ifreq network;
 
1283
  int sd = -1;
 
1284
  bool take_down_interface = false;
 
1285
  uid_t uid;
 
1286
  gid_t gid;
 
1287
  char tempdir[] = "/tmp/mandosXXXXXX";
 
1288
  bool tempdir_created = false;
 
1289
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
1290
  const char *seckey = PATHDIR "/" SECKEY;
 
1291
  const char *pubkey = PATHDIR "/" PUBKEY;
 
1292
  
 
1293
  bool gnutls_initialized = false;
 
1294
  bool gpgme_initialized = false;
 
1295
  float delay = 2.5f;
 
1296
  double retry_interval = 10; /* 10s between trying a server and
 
1297
                                 retrying the same server again */
 
1298
  
 
1299
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
 
1300
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
 
1301
  
 
1302
  uid = getuid();
 
1303
  gid = getgid();
 
1304
  
 
1305
  /* Lower any group privileges we might have, just to be safe */
 
1306
  errno = 0;
 
1307
  ret = setgid(gid);
 
1308
  if(ret == -1){
 
1309
    perror_plus("setgid");
 
1310
  }
 
1311
  
 
1312
  /* Lower user privileges (temporarily) */
 
1313
  errno = 0;
 
1314
  ret = seteuid(uid);
 
1315
  if(ret == -1){
 
1316
    perror_plus("seteuid");
 
1317
  }
 
1318
  
 
1319
  if(quit_now){
 
1320
    goto end;
 
1321
  }
 
1322
  
 
1323
  {
 
1324
    struct argp_option options[] = {
 
1325
      { .name = "debug", .key = 128,
 
1326
        .doc = "Debug mode", .group = 3 },
 
1327
      { .name = "connect", .key = 'c',
 
1328
        .arg = "ADDRESS:PORT",
 
1329
        .doc = "Connect directly to a specific Mandos server",
 
1330
        .group = 1 },
 
1331
      { .name = "interface", .key = 'i',
 
1332
        .arg = "NAME",
 
1333
        .doc = "Network interface that will be used to search for"
 
1334
        " Mandos servers",
 
1335
        .group = 1 },
 
1336
      { .name = "seckey", .key = 's',
 
1337
        .arg = "FILE",
 
1338
        .doc = "OpenPGP secret key file base name",
 
1339
        .group = 1 },
 
1340
      { .name = "pubkey", .key = 'p',
 
1341
        .arg = "FILE",
 
1342
        .doc = "OpenPGP public key file base name",
 
1343
        .group = 2 },
 
1344
      { .name = "dh-bits", .key = 129,
 
1345
        .arg = "BITS",
 
1346
        .doc = "Bit length of the prime number used in the"
 
1347
        " Diffie-Hellman key exchange",
 
1348
        .group = 2 },
 
1349
      { .name = "priority", .key = 130,
 
1350
        .arg = "STRING",
 
1351
        .doc = "GnuTLS priority string for the TLS handshake",
 
1352
        .group = 1 },
 
1353
      { .name = "delay", .key = 131,
 
1354
        .arg = "SECONDS",
 
1355
        .doc = "Maximum delay to wait for interface startup",
 
1356
        .group = 2 },
 
1357
      { .name = "retry", .key = 132,
 
1358
        .arg = "SECONDS",
 
1359
        .doc = "Retry interval used when denied by the mandos server",
 
1360
        .group = 2 },
 
1361
      /*
 
1362
       * These reproduce what we would get without ARGP_NO_HELP
 
1363
       */
 
1364
      { .name = "help", .key = '?',
 
1365
        .doc = "Give this help list", .group = -1 },
 
1366
      { .name = "usage", .key = -3,
 
1367
        .doc = "Give a short usage message", .group = -1 },
 
1368
      { .name = "version", .key = 'V',
 
1369
        .doc = "Print program version", .group = -1 },
 
1370
      { .name = NULL }
 
1371
    };
 
1372
    
 
1373
    error_t parse_opt(int key, char *arg,
 
1374
                      struct argp_state *state){
 
1375
      errno = 0;
 
1376
      switch(key){
 
1377
      case 128:                 /* --debug */
 
1378
        debug = true;
 
1379
        break;
 
1380
      case 'c':                 /* --connect */
 
1381
        connect_to = arg;
 
1382
        break;
 
1383
      case 'i':                 /* --interface */
 
1384
        interface = arg;
 
1385
        break;
 
1386
      case 's':                 /* --seckey */
 
1387
        seckey = arg;
 
1388
        break;
 
1389
      case 'p':                 /* --pubkey */
 
1390
        pubkey = arg;
 
1391
        break;
 
1392
      case 129:                 /* --dh-bits */
 
1393
        errno = 0;
 
1394
        tmpmax = strtoimax(arg, &tmp, 10);
 
1395
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1396
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
 
1397
          argp_error(state, "Bad number of DH bits");
 
1398
        }
 
1399
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
 
1400
        break;
 
1401
      case 130:                 /* --priority */
 
1402
        mc.priority = arg;
 
1403
        break;
 
1404
      case 131:                 /* --delay */
 
1405
        errno = 0;
 
1406
        delay = strtof(arg, &tmp);
 
1407
        if(errno != 0 or tmp == arg or *tmp != '\0'){
 
1408
          argp_error(state, "Bad delay");
 
1409
        }
 
1410
      case 132:                 /* --retry */
 
1411
        errno = 0;
 
1412
        retry_interval = strtod(arg, &tmp);
 
1413
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1414
           or (retry_interval * 1000) > INT_MAX){
 
1415
          argp_error(state, "Bad retry interval");
 
1416
        }
 
1417
        break;
 
1418
        /*
 
1419
         * These reproduce what we would get without ARGP_NO_HELP
 
1420
         */
 
1421
      case '?':                 /* --help */
 
1422
        argp_state_help(state, state->out_stream,
 
1423
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
 
1424
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
1425
      case -3:                  /* --usage */
 
1426
        argp_state_help(state, state->out_stream,
 
1427
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
1428
      case 'V':                 /* --version */
 
1429
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
1430
        exit(argp_err_exit_status);
 
1431
        break;
 
1432
      default:
 
1433
        return ARGP_ERR_UNKNOWN;
 
1434
      }
 
1435
      return errno;
 
1436
    }
 
1437
    
 
1438
    struct argp argp = { .options = options, .parser = parse_opt,
 
1439
                         .args_doc = "",
 
1440
                         .doc = "Mandos client -- Get and decrypt"
 
1441
                         " passwords from a Mandos server" };
 
1442
    ret = argp_parse(&argp, argc, argv,
 
1443
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
1444
    switch(ret){
 
1445
    case 0:
 
1446
      break;
 
1447
    case ENOMEM:
 
1448
    default:
 
1449
      errno = ret;
 
1450
      perror_plus("argp_parse");
 
1451
      exitcode = EX_OSERR;
 
1452
      goto end;
 
1453
    case EINVAL:
 
1454
      exitcode = EX_USAGE;
 
1455
      goto end;
 
1456
    }
 
1457
  }
 
1458
  
 
1459
  if(not debug){
 
1460
    avahi_set_log_function(empty_log);
 
1461
  }
 
1462
 
 
1463
  if(interface[0] == '\0'){
 
1464
    struct dirent **direntries;
 
1465
    ret = scandir(sys_class_net, &direntries, good_interface,
 
1466
                  alphasort);
 
1467
    if(ret >= 1){
 
1468
      /* Pick the first good interface */
 
1469
      interface = strdup(direntries[0]->d_name);
 
1470
      if(debug){
 
1471
        fprintf(stderr, "Using interface \"%s\"\n", interface);
 
1472
      }
 
1473
      if(interface == NULL){
 
1474
        perror_plus("malloc");
 
1475
        free(direntries);
 
1476
        exitcode = EXIT_FAILURE;
 
1477
        goto end;
 
1478
      }
 
1479
      free(direntries);
 
1480
    } else {
 
1481
      free(direntries);
 
1482
      fprintf(stderr, "Could not find a network interface\n");
 
1483
      exitcode = EXIT_FAILURE;
 
1484
      goto end;
 
1485
    }
 
1486
  }
 
1487
  
 
1488
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
 
1489
     from the signal handler */
 
1490
  /* Initialize the pseudo-RNG for Avahi */
 
1491
  srand((unsigned int) time(NULL));
 
1492
  mc.simple_poll = avahi_simple_poll_new();
 
1493
  if(mc.simple_poll == NULL){
 
1494
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
1495
    exitcode = EX_UNAVAILABLE;
 
1496
    goto end;
 
1497
  }
 
1498
  
 
1499
  sigemptyset(&sigterm_action.sa_mask);
 
1500
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
 
1501
  if(ret == -1){
 
1502
    perror_plus("sigaddset");
 
1503
    exitcode = EX_OSERR;
 
1504
    goto end;
 
1505
  }
 
1506
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
 
1507
  if(ret == -1){
 
1508
    perror_plus("sigaddset");
 
1509
    exitcode = EX_OSERR;
 
1510
    goto end;
 
1511
  }
 
1512
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
 
1513
  if(ret == -1){
 
1514
    perror_plus("sigaddset");
 
1515
    exitcode = EX_OSERR;
 
1516
    goto end;
 
1517
  }
 
1518
  /* Need to check if the handler is SIG_IGN before handling:
 
1519
     | [[info:libc:Initial Signal Actions]] |
 
1520
     | [[info:libc:Basic Signal Handling]]  |
 
1521
  */
 
1522
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
 
1523
  if(ret == -1){
 
1524
    perror_plus("sigaction");
 
1525
    return EX_OSERR;
 
1526
  }
 
1527
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1528
    ret = sigaction(SIGINT, &sigterm_action, NULL);
 
1529
    if(ret == -1){
 
1530
      perror_plus("sigaction");
 
1531
      exitcode = EX_OSERR;
 
1532
      goto end;
 
1533
    }
 
1534
  }
 
1535
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
 
1536
  if(ret == -1){
 
1537
    perror_plus("sigaction");
 
1538
    return EX_OSERR;
 
1539
  }
 
1540
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1541
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
 
1542
    if(ret == -1){
 
1543
      perror_plus("sigaction");
 
1544
      exitcode = EX_OSERR;
 
1545
      goto end;
 
1546
    }
 
1547
  }
 
1548
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
 
1549
  if(ret == -1){
 
1550
    perror_plus("sigaction");
 
1551
    return EX_OSERR;
 
1552
  }
 
1553
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1554
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
 
1555
    if(ret == -1){
 
1556
      perror_plus("sigaction");
 
1557
      exitcode = EX_OSERR;
 
1558
      goto end;
 
1559
    }
 
1560
  }
 
1561
  
 
1562
  /* If the interface is down, bring it up */
 
1563
  if(strcmp(interface, "none") != 0){
 
1564
    if_index = (AvahiIfIndex) if_nametoindex(interface);
 
1565
    if(if_index == 0){
 
1566
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
1567
      exitcode = EX_UNAVAILABLE;
 
1568
      goto end;
 
1569
    }
 
1570
    
 
1571
    if(quit_now){
 
1572
      goto end;
 
1573
    }
 
1574
    
 
1575
    /* Re-raise priviliges */
 
1576
    errno = 0;
 
1577
    ret = seteuid(0);
 
1578
    if(ret == -1){
 
1579
      perror_plus("seteuid");
 
1580
    }
 
1581
    
 
1582
#ifdef __linux__
 
1583
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1584
       messages about the network interface to mess up the prompt */
 
1585
    ret = klogctl(8, NULL, 5);
 
1586
    bool restore_loglevel = true;
 
1587
    if(ret == -1){
 
1588
      restore_loglevel = false;
 
1589
      perror_plus("klogctl");
 
1590
    }
 
1591
#endif  /* __linux__ */
 
1592
    
 
1593
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1594
    if(sd < 0){
 
1595
      perror_plus("socket");
 
1596
      exitcode = EX_OSERR;
 
1597
#ifdef __linux__
 
1598
      if(restore_loglevel){
 
1599
        ret = klogctl(7, NULL, 0);
 
1600
        if(ret == -1){
 
1601
          perror_plus("klogctl");
 
1602
        }
 
1603
      }
 
1604
#endif  /* __linux__ */
 
1605
      /* Lower privileges */
 
1606
      errno = 0;
 
1607
      ret = seteuid(uid);
 
1608
      if(ret == -1){
 
1609
        perror_plus("seteuid");
 
1610
      }
 
1611
      goto end;
 
1612
    }
 
1613
    strcpy(network.ifr_name, interface);
 
1614
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1615
    if(ret == -1){
 
1616
      perror_plus("ioctl SIOCGIFFLAGS");
 
1617
#ifdef __linux__
 
1618
      if(restore_loglevel){
 
1619
        ret = klogctl(7, NULL, 0);
 
1620
        if(ret == -1){
 
1621
          perror_plus("klogctl");
 
1622
        }
 
1623
      }
 
1624
#endif  /* __linux__ */
 
1625
      exitcode = EX_OSERR;
 
1626
      /* Lower privileges */
 
1627
      errno = 0;
 
1628
      ret = seteuid(uid);
 
1629
      if(ret == -1){
 
1630
        perror_plus("seteuid");
 
1631
      }
 
1632
      goto end;
 
1633
    }
 
1634
    if((network.ifr_flags & IFF_UP) == 0){
 
1635
      network.ifr_flags |= IFF_UP;
 
1636
      take_down_interface = true;
 
1637
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1638
      if(ret == -1){
 
1639
        take_down_interface = false;
 
1640
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
1641
        exitcode = EX_OSERR;
 
1642
#ifdef __linux__
 
1643
        if(restore_loglevel){
 
1644
          ret = klogctl(7, NULL, 0);
 
1645
          if(ret == -1){
 
1646
            perror_plus("klogctl");
 
1647
          }
 
1648
        }
 
1649
#endif  /* __linux__ */
 
1650
        /* Lower privileges */
 
1651
        errno = 0;
 
1652
        ret = seteuid(uid);
 
1653
        if(ret == -1){
 
1654
          perror_plus("seteuid");
 
1655
        }
 
1656
        goto end;
 
1657
      }
 
1658
    }
 
1659
    /* Sleep checking until interface is running.
 
1660
       Check every 0.25s, up to total time of delay */
 
1661
    for(int i=0; i < delay * 4; i++){
 
1662
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1663
      if(ret == -1){
 
1664
        perror_plus("ioctl SIOCGIFFLAGS");
 
1665
      } else if(network.ifr_flags & IFF_RUNNING){
 
1666
        break;
 
1667
      }
 
1668
      struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1669
      ret = nanosleep(&sleeptime, NULL);
 
1670
      if(ret == -1 and errno != EINTR){
 
1671
        perror_plus("nanosleep");
 
1672
      }
 
1673
    }
 
1674
    if(not take_down_interface){
 
1675
      /* We won't need the socket anymore */
 
1676
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1677
      if(ret == -1){
 
1678
        perror_plus("close");
 
1679
      }
 
1680
    }
 
1681
#ifdef __linux__
 
1682
    if(restore_loglevel){
 
1683
      /* Restores kernel loglevel to default */
 
1684
      ret = klogctl(7, NULL, 0);
 
1685
      if(ret == -1){
 
1686
        perror_plus("klogctl");
 
1687
      }
 
1688
    }
 
1689
#endif  /* __linux__ */
 
1690
    /* Lower privileges */
 
1691
    errno = 0;
 
1692
    if(take_down_interface){
 
1693
      /* Lower privileges */
 
1694
      ret = seteuid(uid);
 
1695
      if(ret == -1){
 
1696
        perror_plus("seteuid");
 
1697
      }
 
1698
    } else {
 
1699
      /* Lower privileges permanently */
 
1700
      ret = setuid(uid);
 
1701
      if(ret == -1){
 
1702
        perror_plus("setuid");
 
1703
      }
 
1704
    }
 
1705
  }
 
1706
  
 
1707
  if(quit_now){
 
1708
    goto end;
 
1709
  }
 
1710
  
 
1711
  ret = init_gnutls_global(pubkey, seckey);
 
1712
  if(ret == -1){
 
1713
    fprintf(stderr, "init_gnutls_global failed\n");
 
1714
    exitcode = EX_UNAVAILABLE;
 
1715
    goto end;
 
1716
  } else {
 
1717
    gnutls_initialized = true;
 
1718
  }
 
1719
  
 
1720
  if(quit_now){
 
1721
    goto end;
 
1722
  }
 
1723
  
 
1724
  if(mkdtemp(tempdir) == NULL){
 
1725
    perror_plus("mkdtemp");
 
1726
    goto end;
 
1727
  }
 
1728
  tempdir_created = true;
 
1729
  
 
1730
  if(quit_now){
 
1731
    goto end;
 
1732
  }
 
1733
  
 
1734
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
1735
    fprintf(stderr, "init_gpgme failed\n");
 
1736
    exitcode = EX_UNAVAILABLE;
 
1737
    goto end;
 
1738
  } else {
 
1739
    gpgme_initialized = true;
 
1740
  }
 
1741
  
 
1742
  if(quit_now){
 
1743
    goto end;
 
1744
  }
 
1745
  
 
1746
  if(connect_to != NULL){
 
1747
    /* Connect directly, do not use Zeroconf */
 
1748
    /* (Mainly meant for debugging) */
 
1749
    char *address = strrchr(connect_to, ':');
 
1750
    if(address == NULL){
 
1751
      fprintf(stderr, "No colon in address\n");
 
1752
      exitcode = EX_USAGE;
 
1753
      goto end;
 
1754
    }
 
1755
    
 
1756
    if(quit_now){
 
1757
      goto end;
 
1758
    }
 
1759
    
 
1760
    uint16_t port;
 
1761
    errno = 0;
 
1762
    tmpmax = strtoimax(address+1, &tmp, 10);
 
1763
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
 
1764
       or tmpmax != (uint16_t)tmpmax){
 
1765
      fprintf(stderr, "Bad port number\n");
 
1766
      exitcode = EX_USAGE;
 
1767
      goto end;
 
1768
    }
 
1769
  
 
1770
    if(quit_now){
 
1771
      goto end;
 
1772
    }
 
1773
    
 
1774
    port = (uint16_t)tmpmax;
 
1775
    *address = '\0';
 
1776
    address = connect_to;
 
1777
    /* Colon in address indicates IPv6 */
 
1778
    int af;
 
1779
    if(strchr(address, ':') != NULL){
 
1780
      af = AF_INET6;
 
1781
    } else {
 
1782
      af = AF_INET;
 
1783
    }
 
1784
    
 
1785
    if(quit_now){
 
1786
      goto end;
 
1787
    }
 
1788
 
 
1789
    while(not quit_now){
 
1790
      ret = start_mandos_communication(address, port, if_index, af);
 
1791
      if(quit_now or ret == 0){
 
1792
        break;
 
1793
      }
 
1794
      sleep((int)retry_interval or 1);
 
1795
    };
 
1796
 
 
1797
    if (not quit_now){
 
1798
      exitcode = EXIT_SUCCESS;
 
1799
    }
 
1800
 
 
1801
    goto end;
 
1802
  }
 
1803
  
 
1804
  if(quit_now){
 
1805
    goto end;
 
1806
  }
 
1807
  
 
1808
  {
 
1809
    AvahiServerConfig config;
 
1810
    /* Do not publish any local Zeroconf records */
 
1811
    avahi_server_config_init(&config);
 
1812
    config.publish_hinfo = 0;
 
1813
    config.publish_addresses = 0;
 
1814
    config.publish_workstation = 0;
 
1815
    config.publish_domain = 0;
 
1816
    
 
1817
    /* Allocate a new server */
 
1818
    mc.server = avahi_server_new(avahi_simple_poll_get
 
1819
                                 (mc.simple_poll), &config, NULL,
 
1820
                                 NULL, &error);
 
1821
    
 
1822
    /* Free the Avahi configuration data */
 
1823
    avahi_server_config_free(&config);
 
1824
  }
 
1825
  
 
1826
  /* Check if creating the Avahi server object succeeded */
 
1827
  if(mc.server == NULL){
 
1828
    fprintf(stderr, "Failed to create Avahi server: %s\n",
 
1829
            avahi_strerror(error));
 
1830
    exitcode = EX_UNAVAILABLE;
 
1831
    goto end;
 
1832
  }
 
1833
  
 
1834
  if(quit_now){
 
1835
    goto end;
 
1836
  }
 
1837
  
 
1838
  /* Create the Avahi service browser */
 
1839
  sb = avahi_s_service_browser_new(mc.server, if_index,
 
1840
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
 
1841
                                   NULL, 0, browse_callback, NULL);
 
1842
  if(sb == NULL){
 
1843
    fprintf(stderr, "Failed to create service browser: %s\n",
 
1844
            avahi_strerror(avahi_server_errno(mc.server)));
 
1845
    exitcode = EX_UNAVAILABLE;
 
1846
    goto end;
 
1847
  }
 
1848
  
 
1849
  if(quit_now){
 
1850
    goto end;
 
1851
  }
 
1852
  
 
1853
  /* Run the main loop */
 
1854
  
 
1855
  if(debug){
 
1856
    fprintf(stderr, "Starting Avahi loop search\n");
 
1857
  }
 
1858
 
 
1859
  ret = avahi_loop_with_timeout(mc.simple_poll,
 
1860
                                (int)(retry_interval * 1000));
 
1861
  if(debug){
 
1862
    fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
 
1863
            (ret == 0) ? "successfully" : "with error");
 
1864
  }
 
1865
  
 
1866
 end:
 
1867
  
 
1868
  if(debug){
 
1869
    fprintf(stderr, "%s exiting\n", argv[0]);
 
1870
  }
 
1871
  
 
1872
  /* Cleanup things */
 
1873
  if(sb != NULL)
 
1874
    avahi_s_service_browser_free(sb);
 
1875
  
 
1876
  if(mc.server != NULL)
 
1877
    avahi_server_free(mc.server);
 
1878
  
 
1879
  if(mc.simple_poll != NULL)
 
1880
    avahi_simple_poll_free(mc.simple_poll);
 
1881
  
 
1882
  if(gnutls_initialized){
 
1883
    gnutls_certificate_free_credentials(mc.cred);
 
1884
    gnutls_global_deinit();
 
1885
    gnutls_dh_params_deinit(mc.dh_params);
 
1886
  }
 
1887
  
 
1888
  if(gpgme_initialized){
 
1889
    gpgme_release(mc.ctx);
 
1890
  }
 
1891
 
 
1892
  /* Cleans up the circular linked list of Mandos servers the client
 
1893
     has seen */
 
1894
  if(mc.current_server != NULL){
 
1895
    mc.current_server->prev->next = NULL;
 
1896
    while(mc.current_server != NULL){
 
1897
      server *next = mc.current_server->next;
 
1898
      free(mc.current_server);
 
1899
      mc.current_server = next;
 
1900
    }
 
1901
  }
 
1902
  
 
1903
  /* Take down the network interface */
 
1904
  if(take_down_interface){
 
1905
    /* Re-raise priviliges */
 
1906
    errno = 0;
 
1907
    ret = seteuid(0);
 
1908
    if(ret == -1){
 
1909
      perror_plus("seteuid");
 
1910
    }
 
1911
    if(geteuid() == 0){
 
1912
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1913
      if(ret == -1){
 
1914
        perror_plus("ioctl SIOCGIFFLAGS");
 
1915
      } else if(network.ifr_flags & IFF_UP) {
 
1916
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1917
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1918
        if(ret == -1){
 
1919
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1920
        }
 
1921
      }
 
1922
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1923
      if(ret == -1){
 
1924
        perror_plus("close");
 
1925
      }
 
1926
      /* Lower privileges permanently */
 
1927
      errno = 0;
 
1928
      ret = setuid(uid);
 
1929
      if(ret == -1){
 
1930
        perror_plus("setuid");
 
1931
      }
 
1932
    }
 
1933
  }
 
1934
  
 
1935
  /* Removes the GPGME temp directory and all files inside */
 
1936
  if(tempdir_created){
 
1937
    struct dirent **direntries = NULL;
 
1938
    struct dirent *direntry = NULL;
 
1939
    ret = scandir(tempdir, &direntries, notdotentries, alphasort);
 
1940
    if (ret > 0){
 
1941
      for(int i = 0; i < ret; i++){
 
1942
        direntry = direntries[i];
 
1943
        char *fullname = NULL;
 
1944
        ret = asprintf(&fullname, "%s/%s", tempdir,
 
1945
                       direntry->d_name);
 
1946
        if(ret < 0){
 
1947
          perror_plus("asprintf");
 
1948
          continue;
 
1949
        }
 
1950
        ret = remove(fullname);
 
1951
        if(ret == -1){
 
1952
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
 
1953
                  strerror(errno));
 
1954
        }
 
1955
        free(fullname);
 
1956
      }
 
1957
    }
 
1958
 
 
1959
    /* need to be cleaned even if ret == 0 because man page doesn't
 
1960
       specify */
 
1961
    free(direntries);
 
1962
    if (ret == -1){
 
1963
      perror_plus("scandir");
 
1964
    }
 
1965
    ret = rmdir(tempdir);
 
1966
    if(ret == -1 and errno != ENOENT){
 
1967
      perror_plus("rmdir");
 
1968
    }
 
1969
  }
 
1970
  
 
1971
  if(quit_now){
 
1972
    sigemptyset(&old_sigterm_action.sa_mask);
 
1973
    old_sigterm_action.sa_handler = SIG_DFL;
 
1974
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
 
1975
                                            &old_sigterm_action,
 
1976
                                            NULL));
 
1977
    if(ret == -1){
 
1978
      perror_plus("sigaction");
 
1979
    }
 
1980
    do {
 
1981
      ret = raise(signal_received);
 
1982
    } while(ret != 0 and errno == EINTR);
 
1983
    if(ret != 0){
 
1984
      perror_plus("raise");
 
1985
      abort();
 
1986
    }
 
1987
    TEMP_FAILURE_RETRY(pause());
 
1988
  }
 
1989
  
 
1990
  return exitcode;
 
1991
}