/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

  • Committer: Björn Påhlsson
  • Date: 2011-06-23 22:27:15 UTC
  • mto: (237.7.33 trunk)
  • mto: This revision was merged to the branch mainline in revision 284.
  • Revision ID: belorn@fukt.bsnet.se-20110623222715-q5wro9ma9iyjl367
* Makefile (CFLAGS): Added "-lrt" to include real time library.
* plugins.d/mandos-client.c: use scandir(3) instead of readdir(3)
                             Prefix all debug output with "Mandos plugin " + program_invocation_short_name
                             Retry servers that failed to provide password.
                             New option --retry SECONDS that sets the interval between rechecking.
                             --retry also controls how often it retries a server when using --connect.
* plugins.d/splashy.c:  Prefix all debug output with "Mandos plugin " + program_invocation_short_name
* plugins.d/usplash.c: --||--
* plugins.d/askpass-fifo.c: --||--
* plugins.d/password-prompt.c: --||--
* plugins.d/plymouth.c: --||--
* mandos: Lower logger level from warning to info on failed client requests because client was disabled or unknown fingerprint.
* plugins.d/plymouth.c (get_pid): bug fix. Was not calling free on direntries. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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, program_invocation_short_name */
 
66
#include <time.h>               /* nanosleep(), time(), sleep() */
 
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(), seteuid(),
 
75
                                   setgid(), pause() */
 
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
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
86
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
 
87
 
 
88
#ifdef __linux__
 
89
#include <sys/klog.h>           /* klogctl() */
 
90
#endif  /* __linux__ */
 
91
 
 
92
/* Avahi */
 
93
/* All Avahi types, constants and functions
 
94
 Avahi*, avahi_*,
 
95
 AVAHI_* */
 
96
#include <avahi-core/core.h>
 
97
#include <avahi-core/lookup.h>
 
98
#include <avahi-core/log.h>
 
99
#include <avahi-common/simple-watch.h>
 
100
#include <avahi-common/malloc.h>
 
101
#include <avahi-common/error.h>
 
102
 
 
103
/* GnuTLS */
 
104
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
 
105
                                   functions:
 
106
                                   gnutls_*
 
107
                                   init_gnutls_session(),
 
108
                                   GNUTLS_* */
 
109
#include <gnutls/openpgp.h>
 
110
                          /* gnutls_certificate_set_openpgp_key_file(),
 
111
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
112
 
 
113
/* GPGME */
 
114
#include <gpgme.h>              /* All GPGME types, constants and
 
115
                                   functions:
 
116
                                   gpgme_*
 
117
                                   GPGME_PROTOCOL_OpenPGP,
 
118
                                   GPG_ERR_NO_* */
 
119
 
 
120
#define BUFFER_SIZE 256
 
121
 
 
122
#define PATHDIR "/conf/conf.d/mandos"
 
123
#define SECKEY "seckey.txt"
 
124
#define PUBKEY "pubkey.txt"
 
125
 
 
126
bool debug = false;
 
127
static const char mandos_protocol_version[] = "1";
 
128
const char *argp_program_version = "mandos-client " VERSION;
 
129
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
130
static const char sys_class_net[] = "/sys/class/net";
 
131
char *connect_to = NULL;
 
132
 
 
133
/* Doubly linked list that need to be circular linked when ever used */
 
134
typedef struct server{
 
135
  const char *ip;
 
136
  uint16_t port;
 
137
  AvahiIfIndex if_index;
 
138
  int af;
 
139
  struct timespec last_seen;
 
140
  struct server *next;
 
141
  struct server *prev;
 
142
} server;
 
143
 
 
144
/* Used for passing in values through the Avahi callback functions */
 
145
typedef struct {
 
146
  AvahiSimplePoll *simple_poll;
 
147
  AvahiServer *server;
 
148
  gnutls_certificate_credentials_t cred;
 
149
  unsigned int dh_bits;
 
150
  gnutls_dh_params_t dh_params;
 
151
  const char *priority;
 
152
  gpgme_ctx_t ctx;
 
153
  server *current_server;
 
154
} mandos_context;
 
155
 
 
156
/* global context so signal handler can reach it*/
 
157
mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
158
                      .dh_bits = 1024, .priority = "SECURE256"
 
159
                      ":!CTYPE-X.509:+CTYPE-OPENPGP", .current_server = NULL };
 
160
 
 
161
sig_atomic_t quit_now = 0;
 
162
int signal_received = 0;
 
163
 
 
164
/* Function to use when printing errors */
 
165
void perror_plus(const char *print_text){
 
166
  fprintf(stderr, "Mandos plugin %s: ", program_invocation_short_name);
 
167
  perror(print_text);
 
168
}
 
169
 
 
170
/*
 
171
 * Make additional room in "buffer" for at least BUFFER_SIZE more
 
172
 * bytes. "buffer_capacity" is how much is currently allocated,
 
173
 * "buffer_length" is how much is already used.
 
174
 */
 
175
size_t incbuffer(char **buffer, size_t buffer_length,
 
176
                  size_t buffer_capacity){
 
177
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
 
178
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
179
    if(buffer == NULL){
 
180
      return 0;
 
181
    }
 
182
    buffer_capacity += BUFFER_SIZE;
 
183
  }
 
184
  return buffer_capacity;
 
185
}
 
186
 
 
187
int add_server(const char *ip, uint16_t port,
 
188
                 AvahiIfIndex if_index,
 
189
                 int af){
 
190
  int ret;
 
191
  server *new_server = malloc(sizeof(server));
 
192
  if(new_server == NULL){
 
193
    perror_plus("malloc");
 
194
    return -1;
 
195
  }
 
196
  *new_server = (server){ .ip = strdup(ip),
 
197
                         .port = port,
 
198
                         .if_index = if_index,
 
199
                         .af = af };
 
200
  if(new_server->ip == NULL){
 
201
    perror_plus("strdup");
 
202
    return -1;    
 
203
  }
 
204
  /* uniqe case of first server */
 
205
  if (mc.current_server == NULL){
 
206
    new_server->next = new_server;
 
207
    new_server->prev = new_server;
 
208
    mc.current_server = new_server;
 
209
  /* Placing the new server last in the list */
 
210
  } else {
 
211
    new_server->next = mc.current_server;
 
212
    new_server->prev = mc.current_server->prev;
 
213
    new_server->prev->next = new_server;
 
214
    mc.current_server->prev = new_server;
 
215
  }
 
216
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
 
217
  if(ret == -1){
 
218
    perror_plus("clock_gettime");
 
219
    return -1;
 
220
  }
 
221
  return 0;
 
222
}
 
223
 
 
224
/* 
 
225
 * Initialize GPGME.
 
226
 */
 
227
static bool init_gpgme(const char *seckey,
 
228
                       const char *pubkey, const char *tempdir){
 
229
  gpgme_error_t rc;
 
230
  gpgme_engine_info_t engine_info;
 
231
  
 
232
  
 
233
  /*
 
234
   * Helper function to insert pub and seckey to the engine keyring.
 
235
   */
 
236
  bool import_key(const char *filename){
 
237
    int ret;
 
238
    int fd;
 
239
    gpgme_data_t pgp_data;
 
240
    
 
241
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
242
    if(fd == -1){
 
243
      perror_plus("open");
 
244
      return false;
 
245
    }
 
246
    
 
247
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
248
    if(rc != GPG_ERR_NO_ERROR){
 
249
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
250
              gpgme_strsource(rc), gpgme_strerror(rc));
 
251
      return false;
 
252
    }
 
253
    
 
254
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
255
    if(rc != GPG_ERR_NO_ERROR){
 
256
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
 
257
              gpgme_strsource(rc), gpgme_strerror(rc));
 
258
      return false;
 
259
    }
 
260
    
 
261
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
262
    if(ret == -1){
 
263
      perror_plus("close");
 
264
    }
 
265
    gpgme_data_release(pgp_data);
 
266
    return true;
 
267
  }
 
268
  
 
269
  if(debug){
 
270
    fprintf(stderr, "Initializing GPGME\n");
 
271
  }
 
272
  
 
273
  /* Init GPGME */
 
274
  gpgme_check_version(NULL);
 
275
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
276
  if(rc != GPG_ERR_NO_ERROR){
 
277
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
278
            gpgme_strsource(rc), gpgme_strerror(rc));
 
279
    return false;
 
280
  }
 
281
  
 
282
    /* Set GPGME home directory for the OpenPGP engine only */
 
283
  rc = gpgme_get_engine_info(&engine_info);
 
284
  if(rc != GPG_ERR_NO_ERROR){
 
285
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
286
            gpgme_strsource(rc), gpgme_strerror(rc));
 
287
    return false;
 
288
  }
 
289
  while(engine_info != NULL){
 
290
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
 
291
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
 
292
                            engine_info->file_name, tempdir);
 
293
      break;
 
294
    }
 
295
    engine_info = engine_info->next;
 
296
  }
 
297
  if(engine_info == NULL){
 
298
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
299
    return false;
 
300
  }
 
301
  
 
302
  /* Create new GPGME "context" */
 
303
  rc = gpgme_new(&(mc.ctx));
 
304
  if(rc != GPG_ERR_NO_ERROR){
 
305
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
306
            gpgme_strsource(rc), gpgme_strerror(rc));
 
307
    return false;
 
308
  }
 
309
  
 
310
  if(not import_key(pubkey) or not import_key(seckey)){
 
311
    return false;
 
312
  }
 
313
  
 
314
  return true;
 
315
}
 
316
 
 
317
/* 
 
318
 * Decrypt OpenPGP data.
 
319
 * Returns -1 on error
 
320
 */
 
321
static ssize_t pgp_packet_decrypt(const char *cryptotext,
 
322
                                  size_t crypto_size,
 
323
                                  char **plaintext){
 
324
  gpgme_data_t dh_crypto, dh_plain;
 
325
  gpgme_error_t rc;
 
326
  ssize_t ret;
 
327
  size_t plaintext_capacity = 0;
 
328
  ssize_t plaintext_length = 0;
 
329
  
 
330
  if(debug){
 
331
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
332
  }
 
333
  
 
334
  /* Create new GPGME data buffer from memory cryptotext */
 
335
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
336
                               0);
 
337
  if(rc != GPG_ERR_NO_ERROR){
 
338
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
339
            gpgme_strsource(rc), gpgme_strerror(rc));
 
340
    return -1;
 
341
  }
 
342
  
 
343
  /* Create new empty GPGME data buffer for the plaintext */
 
344
  rc = gpgme_data_new(&dh_plain);
 
345
  if(rc != GPG_ERR_NO_ERROR){
 
346
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
347
            gpgme_strsource(rc), gpgme_strerror(rc));
 
348
    gpgme_data_release(dh_crypto);
 
349
    return -1;
 
350
  }
 
351
  
 
352
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
353
     data buffer */
 
354
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
355
  if(rc != GPG_ERR_NO_ERROR){
 
356
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
357
            gpgme_strsource(rc), gpgme_strerror(rc));
 
358
    plaintext_length = -1;
 
359
    if(debug){
 
360
      gpgme_decrypt_result_t result;
 
361
      result = gpgme_op_decrypt_result(mc.ctx);
 
362
      if(result == NULL){
 
363
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
364
      } else {
 
365
        fprintf(stderr, "Unsupported algorithm: %s\n",
 
366
                result->unsupported_algorithm);
 
367
        fprintf(stderr, "Wrong key usage: %u\n",
 
368
                result->wrong_key_usage);
 
369
        if(result->file_name != NULL){
 
370
          fprintf(stderr, "File name: %s\n", result->file_name);
 
371
        }
 
372
        gpgme_recipient_t recipient;
 
373
        recipient = result->recipients;
 
374
        while(recipient != NULL){
 
375
          fprintf(stderr, "Public key algorithm: %s\n",
 
376
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
377
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
378
          fprintf(stderr, "Secret key available: %s\n",
 
379
                  recipient->status == GPG_ERR_NO_SECKEY
 
380
                  ? "No" : "Yes");
 
381
          recipient = recipient->next;
 
382
        }
 
383
      }
 
384
    }
 
385
    goto decrypt_end;
 
386
  }
 
387
  
 
388
  if(debug){
 
389
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
390
  }
 
391
  
 
392
  /* Seek back to the beginning of the GPGME plaintext data buffer */
 
393
  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
 
394
    perror_plus("gpgme_data_seek");
 
395
    plaintext_length = -1;
 
396
    goto decrypt_end;
 
397
  }
 
398
  
 
399
  *plaintext = NULL;
 
400
  while(true){
 
401
    plaintext_capacity = incbuffer(plaintext,
 
402
                                      (size_t)plaintext_length,
 
403
                                      plaintext_capacity);
 
404
    if(plaintext_capacity == 0){
 
405
        perror_plus("incbuffer");
 
406
        plaintext_length = -1;
 
407
        goto decrypt_end;
 
408
    }
 
409
    
 
410
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
411
                          BUFFER_SIZE);
 
412
    /* Print the data, if any */
 
413
    if(ret == 0){
 
414
      /* EOF */
 
415
      break;
 
416
    }
 
417
    if(ret < 0){
 
418
      perror_plus("gpgme_data_read");
 
419
      plaintext_length = -1;
 
420
      goto decrypt_end;
 
421
    }
 
422
    plaintext_length += ret;
 
423
  }
 
424
  
 
425
  if(debug){
 
426
    fprintf(stderr, "Decrypted password is: ");
 
427
    for(ssize_t i = 0; i < plaintext_length; i++){
 
428
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
 
429
    }
 
430
    fprintf(stderr, "\n");
 
431
  }
 
432
  
 
433
 decrypt_end:
 
434
  
 
435
  /* Delete the GPGME cryptotext data buffer */
 
436
  gpgme_data_release(dh_crypto);
 
437
  
 
438
  /* Delete the GPGME plaintext data buffer */
 
439
  gpgme_data_release(dh_plain);
 
440
  return plaintext_length;
 
441
}
 
442
 
 
443
static const char * safer_gnutls_strerror(int value){
 
444
  const char *ret = gnutls_strerror(value); /* Spurious warning from
 
445
                                               -Wunreachable-code */
 
446
  if(ret == NULL)
 
447
    ret = "(unknown)";
 
448
  return ret;
 
449
}
 
450
 
 
451
/* GnuTLS log function callback */
 
452
static void debuggnutls(__attribute__((unused)) int level,
 
453
                        const char* string){
 
454
  fprintf(stderr, "GnuTLS: %s", string);
 
455
}
 
456
 
 
457
static int init_gnutls_global(const char *pubkeyfilename,
 
458
                              const char *seckeyfilename){
 
459
  int ret;
 
460
  
 
461
  if(debug){
 
462
    fprintf(stderr, "Initializing GnuTLS\n");
 
463
  }
 
464
  
 
465
  ret = gnutls_global_init();
 
466
  if(ret != GNUTLS_E_SUCCESS){
 
467
    fprintf(stderr, "GnuTLS global_init: %s\n",
 
468
            safer_gnutls_strerror(ret));
 
469
    return -1;
 
470
  }
 
471
  
 
472
  if(debug){
 
473
    /* "Use a log level over 10 to enable all debugging options."
 
474
     * - GnuTLS manual
 
475
     */
 
476
    gnutls_global_set_log_level(11);
 
477
    gnutls_global_set_log_function(debuggnutls);
 
478
  }
 
479
  
 
480
  /* OpenPGP credentials */
 
481
  gnutls_certificate_allocate_credentials(&mc.cred);
 
482
  if(ret != GNUTLS_E_SUCCESS){
 
483
    fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
 
484
                                                    from
 
485
                                                    -Wunreachable-code
 
486
                                                 */
 
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 warnings 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 has been called */
 
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 = (sizeof(ifreq_flags)*2)+3; /* "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, "Wait until first server is found. No timeout!\n");     
 
1213
      }
 
1214
      ret = avahi_simple_poll_iterate(s, -1);
 
1215
    } else {
 
1216
      if (debug){
 
1217
        fprintf(stderr, "Check current_server if we should run it, or wait\n"); 
 
1218
      }
 
1219
      /* the current time */
 
1220
      ret = clock_gettime(CLOCK_MONOTONIC, &now);
 
1221
      if(ret == -1){
 
1222
        perror_plus("clock_gettime");
 
1223
        return -1;
 
1224
      }
 
1225
      /* Calculating in ms how long time between now and server
 
1226
         who we visted longest time ago. Now - last seen.  */
 
1227
      waited_time.tv_sec = now.tv_sec - mc.current_server->last_seen.tv_sec;
 
1228
      waited_time.tv_nsec = now.tv_nsec - mc.current_server->last_seen.tv_nsec;
 
1229
      /* total time is 10s/10000ms. Converting to s to ms by 1000/s, and ns to ms by divind by 1000000. */
 
1230
      block_time = (retry_interval - ((intmax_t)waited_time.tv_sec * 1000)) - ((intmax_t)waited_time.tv_nsec / 1000000);
 
1231
 
 
1232
      if (debug){
 
1233
        fprintf(stderr, "Blocking for %ld ms\n", block_time);   
 
1234
      }
 
1235
 
 
1236
      if(block_time <= 0){
 
1237
        ret = start_mandos_communication(mc.current_server->ip,
 
1238
                                   mc.current_server->port,
 
1239
                                   mc.current_server->if_index,
 
1240
                                   mc.current_server->af);
 
1241
        if(ret == 0){
 
1242
          avahi_simple_poll_quit(mc.simple_poll);
 
1243
          return 0;
 
1244
        }
 
1245
        ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
 
1246
        if(ret == -1){
 
1247
          perror_plus("clock_gettime");
 
1248
          return -1;
 
1249
        }
 
1250
        mc.current_server = mc.current_server->next;
 
1251
        block_time = 0;         /* call avahi to find new mandos servers, but dont block */
 
1252
      }
 
1253
      
 
1254
      ret = avahi_simple_poll_iterate(s, (int)block_time);
 
1255
    }
 
1256
    if(ret != 0){
 
1257
      if (ret > 0 or errno != EINTR) {
 
1258
        return (ret != 1) ? ret : 0;
 
1259
      }
 
1260
    }
 
1261
  }
 
1262
}
 
1263
 
 
1264
int main(int argc, char *argv[]){
 
1265
  AvahiSServiceBrowser *sb = NULL;
 
1266
  int error;
 
1267
  int ret;
 
1268
  intmax_t tmpmax;
 
1269
  char *tmp;
 
1270
  int exitcode = EXIT_SUCCESS;
 
1271
  const char *interface = "";
 
1272
  struct ifreq network;
 
1273
  int sd = -1;
 
1274
  bool take_down_interface = false;
 
1275
  uid_t uid;
 
1276
  gid_t gid;
 
1277
  char tempdir[] = "/tmp/mandosXXXXXX";
 
1278
  bool tempdir_created = false;
 
1279
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
1280
  const char *seckey = PATHDIR "/" SECKEY;
 
1281
  const char *pubkey = PATHDIR "/" PUBKEY;
 
1282
  
 
1283
  bool gnutls_initialized = false;
 
1284
  bool gpgme_initialized = false;
 
1285
  float delay = 2.5f;
 
1286
  double retry_interval = 10; /* 10s between retrying a server and checking again*/
 
1287
  
 
1288
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
 
1289
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
 
1290
  
 
1291
  uid = getuid();
 
1292
  gid = getgid();
 
1293
  
 
1294
  /* Lower any group privileges we might have, just to be safe */
 
1295
  errno = 0;
 
1296
  ret = setgid(gid);
 
1297
  if(ret == -1){
 
1298
    perror_plus("setgid");
 
1299
  }
 
1300
  
 
1301
  /* Lower user privileges (temporarily) */
 
1302
  errno = 0;
 
1303
  ret = seteuid(uid);
 
1304
  if(ret == -1){
 
1305
    perror_plus("seteuid");
 
1306
  }
 
1307
  
 
1308
  if(quit_now){
 
1309
    goto end;
 
1310
  }
 
1311
  
 
1312
  {
 
1313
    struct argp_option options[] = {
 
1314
      { .name = "debug", .key = 128,
 
1315
        .doc = "Debug mode", .group = 3 },
 
1316
      { .name = "connect", .key = 'c',
 
1317
        .arg = "ADDRESS:PORT",
 
1318
        .doc = "Connect directly to a specific Mandos server",
 
1319
        .group = 1 },
 
1320
      { .name = "interface", .key = 'i',
 
1321
        .arg = "NAME",
 
1322
        .doc = "Network interface that will be used to search for"
 
1323
        " Mandos servers",
 
1324
        .group = 1 },
 
1325
      { .name = "seckey", .key = 's',
 
1326
        .arg = "FILE",
 
1327
        .doc = "OpenPGP secret key file base name",
 
1328
        .group = 1 },
 
1329
      { .name = "pubkey", .key = 'p',
 
1330
        .arg = "FILE",
 
1331
        .doc = "OpenPGP public key file base name",
 
1332
        .group = 2 },
 
1333
      { .name = "dh-bits", .key = 129,
 
1334
        .arg = "BITS",
 
1335
        .doc = "Bit length of the prime number used in the"
 
1336
        " Diffie-Hellman key exchange",
 
1337
        .group = 2 },
 
1338
      { .name = "priority", .key = 130,
 
1339
        .arg = "STRING",
 
1340
        .doc = "GnuTLS priority string for the TLS handshake",
 
1341
        .group = 1 },
 
1342
      { .name = "delay", .key = 131,
 
1343
        .arg = "SECONDS",
 
1344
        .doc = "Maximum delay to wait for interface startup",
 
1345
        .group = 2 },
 
1346
      { .name = "retry", .key = 132,
 
1347
        .arg = "SECONDS",
 
1348
        .doc = "Retry interval used when denied by the mandos server",
 
1349
        .group = 2 },
 
1350
      /*
 
1351
       * These reproduce what we would get without ARGP_NO_HELP
 
1352
       */
 
1353
      { .name = "help", .key = '?',
 
1354
        .doc = "Give this help list", .group = -1 },
 
1355
      { .name = "usage", .key = -3,
 
1356
        .doc = "Give a short usage message", .group = -1 },
 
1357
      { .name = "version", .key = 'V',
 
1358
        .doc = "Print program version", .group = -1 },
 
1359
      { .name = NULL }
 
1360
    };
 
1361
    
 
1362
    error_t parse_opt(int key, char *arg,
 
1363
                      struct argp_state *state){
 
1364
      errno = 0;
 
1365
      switch(key){
 
1366
      case 128:                 /* --debug */
 
1367
        debug = true;
 
1368
        break;
 
1369
      case 'c':                 /* --connect */
 
1370
        connect_to = arg;
 
1371
        break;
 
1372
      case 'i':                 /* --interface */
 
1373
        interface = arg;
 
1374
        break;
 
1375
      case 's':                 /* --seckey */
 
1376
        seckey = arg;
 
1377
        break;
 
1378
      case 'p':                 /* --pubkey */
 
1379
        pubkey = arg;
 
1380
        break;
 
1381
      case 129:                 /* --dh-bits */
 
1382
        errno = 0;
 
1383
        tmpmax = strtoimax(arg, &tmp, 10);
 
1384
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1385
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
 
1386
          argp_error(state, "Bad number of DH bits");
 
1387
        }
 
1388
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
 
1389
        break;
 
1390
      case 130:                 /* --priority */
 
1391
        mc.priority = arg;
 
1392
        break;
 
1393
      case 131:                 /* --delay */
 
1394
        errno = 0;
 
1395
        delay = strtof(arg, &tmp);
 
1396
        if(errno != 0 or tmp == arg or *tmp != '\0'){
 
1397
          argp_error(state, "Bad delay");
 
1398
        }
 
1399
      case 132:                 /* --retry */
 
1400
        errno = 0;
 
1401
        retry_interval = strtod(arg, &tmp);
 
1402
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1403
           or (retry_interval * 1000) > INT_MAX){
 
1404
          argp_error(state, "Bad retry interval");
 
1405
        }
 
1406
        break;
 
1407
        /*
 
1408
         * These reproduce what we would get without ARGP_NO_HELP
 
1409
         */
 
1410
      case '?':                 /* --help */
 
1411
        argp_state_help(state, state->out_stream,
 
1412
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
 
1413
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
1414
      case -3:                  /* --usage */
 
1415
        argp_state_help(state, state->out_stream,
 
1416
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
1417
      case 'V':                 /* --version */
 
1418
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
1419
        exit(argp_err_exit_status);
 
1420
        break;
 
1421
      default:
 
1422
        return ARGP_ERR_UNKNOWN;
 
1423
      }
 
1424
      return errno;
 
1425
    }
 
1426
    
 
1427
    struct argp argp = { .options = options, .parser = parse_opt,
 
1428
                         .args_doc = "",
 
1429
                         .doc = "Mandos client -- Get and decrypt"
 
1430
                         " passwords from a Mandos server" };
 
1431
    ret = argp_parse(&argp, argc, argv,
 
1432
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
1433
    switch(ret){
 
1434
    case 0:
 
1435
      break;
 
1436
    case ENOMEM:
 
1437
    default:
 
1438
      errno = ret;
 
1439
      perror_plus("argp_parse");
 
1440
      exitcode = EX_OSERR;
 
1441
      goto end;
 
1442
    case EINVAL:
 
1443
      exitcode = EX_USAGE;
 
1444
      goto end;
 
1445
    }
 
1446
  }
 
1447
  
 
1448
  if(not debug){
 
1449
    avahi_set_log_function(empty_log);
 
1450
  }
 
1451
 
 
1452
  if(interface[0] == '\0'){
 
1453
    struct dirent **direntries;
 
1454
    ret = scandir(sys_class_net, &direntries, good_interface,
 
1455
                  alphasort);
 
1456
    if(ret >= 1){
 
1457
      /* Pick the first good interface */
 
1458
      interface = strdup(direntries[0]->d_name);
 
1459
      if(debug){
 
1460
        fprintf(stderr, "Using interface \"%s\"\n", interface);
 
1461
      }
 
1462
      if(interface == NULL){
 
1463
        perror_plus("malloc");
 
1464
        free(direntries);
 
1465
        exitcode = EXIT_FAILURE;
 
1466
        goto end;
 
1467
      }
 
1468
      free(direntries);
 
1469
    } else {
 
1470
      free(direntries);
 
1471
      fprintf(stderr, "Could not find a network interface\n");
 
1472
      exitcode = EXIT_FAILURE;
 
1473
      goto end;
 
1474
    }
 
1475
  }
 
1476
  
 
1477
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
 
1478
     from the signal handler */
 
1479
  /* Initialize the pseudo-RNG for Avahi */
 
1480
  srand((unsigned int) time(NULL));
 
1481
  mc.simple_poll = avahi_simple_poll_new();
 
1482
  if(mc.simple_poll == NULL){
 
1483
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
1484
    exitcode = EX_UNAVAILABLE;
 
1485
    goto end;
 
1486
  }
 
1487
  
 
1488
  sigemptyset(&sigterm_action.sa_mask);
 
1489
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
 
1490
  if(ret == -1){
 
1491
    perror_plus("sigaddset");
 
1492
    exitcode = EX_OSERR;
 
1493
    goto end;
 
1494
  }
 
1495
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
 
1496
  if(ret == -1){
 
1497
    perror_plus("sigaddset");
 
1498
    exitcode = EX_OSERR;
 
1499
    goto end;
 
1500
  }
 
1501
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
 
1502
  if(ret == -1){
 
1503
    perror_plus("sigaddset");
 
1504
    exitcode = EX_OSERR;
 
1505
    goto end;
 
1506
  }
 
1507
  /* Need to check if the handler is SIG_IGN before handling:
 
1508
     | [[info:libc:Initial Signal Actions]] |
 
1509
     | [[info:libc:Basic Signal Handling]]  |
 
1510
  */
 
1511
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
 
1512
  if(ret == -1){
 
1513
    perror_plus("sigaction");
 
1514
    return EX_OSERR;
 
1515
  }
 
1516
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1517
    ret = sigaction(SIGINT, &sigterm_action, NULL);
 
1518
    if(ret == -1){
 
1519
      perror_plus("sigaction");
 
1520
      exitcode = EX_OSERR;
 
1521
      goto end;
 
1522
    }
 
1523
  }
 
1524
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
 
1525
  if(ret == -1){
 
1526
    perror_plus("sigaction");
 
1527
    return EX_OSERR;
 
1528
  }
 
1529
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1530
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
 
1531
    if(ret == -1){
 
1532
      perror_plus("sigaction");
 
1533
      exitcode = EX_OSERR;
 
1534
      goto end;
 
1535
    }
 
1536
  }
 
1537
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
 
1538
  if(ret == -1){
 
1539
    perror_plus("sigaction");
 
1540
    return EX_OSERR;
 
1541
  }
 
1542
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
1543
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
 
1544
    if(ret == -1){
 
1545
      perror_plus("sigaction");
 
1546
      exitcode = EX_OSERR;
 
1547
      goto end;
 
1548
    }
 
1549
  }
 
1550
  
 
1551
  /* If the interface is down, bring it up */
 
1552
  if(strcmp(interface, "none") != 0){
 
1553
    if_index = (AvahiIfIndex) if_nametoindex(interface);
 
1554
    if(if_index == 0){
 
1555
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
1556
      exitcode = EX_UNAVAILABLE;
 
1557
      goto end;
 
1558
    }
 
1559
    
 
1560
    if(quit_now){
 
1561
      goto end;
 
1562
    }
 
1563
    
 
1564
    /* Re-raise priviliges */
 
1565
    errno = 0;
 
1566
    ret = seteuid(0);
 
1567
    if(ret == -1){
 
1568
      perror_plus("seteuid");
 
1569
    }
 
1570
    
 
1571
#ifdef __linux__
 
1572
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1573
       messages about the network interface to mess up the prompt */
 
1574
    ret = klogctl(8, NULL, 5);
 
1575
    bool restore_loglevel = true;
 
1576
    if(ret == -1){
 
1577
      restore_loglevel = false;
 
1578
      perror_plus("klogctl");
 
1579
    }
 
1580
#endif  /* __linux__ */
 
1581
    
 
1582
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1583
    if(sd < 0){
 
1584
      perror_plus("socket");
 
1585
      exitcode = EX_OSERR;
 
1586
#ifdef __linux__
 
1587
      if(restore_loglevel){
 
1588
        ret = klogctl(7, NULL, 0);
 
1589
        if(ret == -1){
 
1590
          perror_plus("klogctl");
 
1591
        }
 
1592
      }
 
1593
#endif  /* __linux__ */
 
1594
      /* Lower privileges */
 
1595
      errno = 0;
 
1596
      ret = seteuid(uid);
 
1597
      if(ret == -1){
 
1598
        perror_plus("seteuid");
 
1599
      }
 
1600
      goto end;
 
1601
    }
 
1602
    strcpy(network.ifr_name, interface);
 
1603
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1604
    if(ret == -1){
 
1605
      perror_plus("ioctl SIOCGIFFLAGS");
 
1606
#ifdef __linux__
 
1607
      if(restore_loglevel){
 
1608
        ret = klogctl(7, NULL, 0);
 
1609
        if(ret == -1){
 
1610
          perror_plus("klogctl");
 
1611
        }
 
1612
      }
 
1613
#endif  /* __linux__ */
 
1614
      exitcode = EX_OSERR;
 
1615
      /* Lower privileges */
 
1616
      errno = 0;
 
1617
      ret = seteuid(uid);
 
1618
      if(ret == -1){
 
1619
        perror_plus("seteuid");
 
1620
      }
 
1621
      goto end;
 
1622
    }
 
1623
    if((network.ifr_flags & IFF_UP) == 0){
 
1624
      network.ifr_flags |= IFF_UP;
 
1625
      take_down_interface = true;
 
1626
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1627
      if(ret == -1){
 
1628
        take_down_interface = false;
 
1629
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
1630
        exitcode = EX_OSERR;
 
1631
#ifdef __linux__
 
1632
        if(restore_loglevel){
 
1633
          ret = klogctl(7, NULL, 0);
 
1634
          if(ret == -1){
 
1635
            perror_plus("klogctl");
 
1636
          }
 
1637
        }
 
1638
#endif  /* __linux__ */
 
1639
        /* Lower privileges */
 
1640
        errno = 0;
 
1641
        ret = seteuid(uid);
 
1642
        if(ret == -1){
 
1643
          perror_plus("seteuid");
 
1644
        }
 
1645
        goto end;
 
1646
      }
 
1647
    }
 
1648
    /* sleep checking until interface is running. Check every 0.25s, up to total time of delay */
 
1649
    for(int i=0; i < delay * 4; i++){
 
1650
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1651
      if(ret == -1){
 
1652
        perror_plus("ioctl SIOCGIFFLAGS");
 
1653
      } else if(network.ifr_flags & IFF_RUNNING){
 
1654
        break;
 
1655
      }
 
1656
      struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1657
      ret = nanosleep(&sleeptime, NULL);
 
1658
      if(ret == -1 and errno != EINTR){
 
1659
        perror_plus("nanosleep");
 
1660
      }
 
1661
    }
 
1662
    if(not take_down_interface){
 
1663
      /* We won't need the socket anymore */
 
1664
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1665
      if(ret == -1){
 
1666
        perror_plus("close");
 
1667
      }
 
1668
    }
 
1669
#ifdef __linux__
 
1670
    if(restore_loglevel){
 
1671
      /* Restores kernel loglevel to default */
 
1672
      ret = klogctl(7, NULL, 0);
 
1673
      if(ret == -1){
 
1674
        perror_plus("klogctl");
 
1675
      }
 
1676
    }
 
1677
#endif  /* __linux__ */
 
1678
    /* Lower privileges */
 
1679
    errno = 0;
 
1680
    if(take_down_interface){
 
1681
      /* Lower privileges */
 
1682
      ret = seteuid(uid);
 
1683
      if(ret == -1){
 
1684
        perror_plus("seteuid");
 
1685
      }
 
1686
    } else {
 
1687
      /* Lower privileges permanently */
 
1688
      ret = setuid(uid);
 
1689
      if(ret == -1){
 
1690
        perror_plus("setuid");
 
1691
      }
 
1692
    }
 
1693
  }
 
1694
  
 
1695
  if(quit_now){
 
1696
    goto end;
 
1697
  }
 
1698
  
 
1699
  ret = init_gnutls_global(pubkey, seckey);
 
1700
  if(ret == -1){
 
1701
    fprintf(stderr, "init_gnutls_global failed\n");
 
1702
    exitcode = EX_UNAVAILABLE;
 
1703
    goto end;
 
1704
  } else {
 
1705
    gnutls_initialized = true;
 
1706
  }
 
1707
  
 
1708
  if(quit_now){
 
1709
    goto end;
 
1710
  }
 
1711
  
 
1712
  if(mkdtemp(tempdir) == NULL){
 
1713
    perror_plus("mkdtemp");
 
1714
    goto end;
 
1715
  }
 
1716
  tempdir_created = true;
 
1717
  
 
1718
  if(quit_now){
 
1719
    goto end;
 
1720
  }
 
1721
  
 
1722
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
1723
    fprintf(stderr, "init_gpgme failed\n");
 
1724
    exitcode = EX_UNAVAILABLE;
 
1725
    goto end;
 
1726
  } else {
 
1727
    gpgme_initialized = true;
 
1728
  }
 
1729
  
 
1730
  if(quit_now){
 
1731
    goto end;
 
1732
  }
 
1733
  
 
1734
  if(connect_to != NULL){
 
1735
    /* Connect directly, do not use Zeroconf */
 
1736
    /* (Mainly meant for debugging) */
 
1737
    char *address = strrchr(connect_to, ':');
 
1738
    if(address == NULL){
 
1739
      fprintf(stderr, "No colon in address\n");
 
1740
      exitcode = EX_USAGE;
 
1741
      goto end;
 
1742
    }
 
1743
    
 
1744
    if(quit_now){
 
1745
      goto end;
 
1746
    }
 
1747
    
 
1748
    uint16_t port;
 
1749
    errno = 0;
 
1750
    tmpmax = strtoimax(address+1, &tmp, 10);
 
1751
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
 
1752
       or tmpmax != (uint16_t)tmpmax){
 
1753
      fprintf(stderr, "Bad port number\n");
 
1754
      exitcode = EX_USAGE;
 
1755
      goto end;
 
1756
    }
 
1757
  
 
1758
    if(quit_now){
 
1759
      goto end;
 
1760
    }
 
1761
    
 
1762
    port = (uint16_t)tmpmax;
 
1763
    *address = '\0';
 
1764
    address = connect_to;
 
1765
    /* Colon in address indicates IPv6 */
 
1766
    int af;
 
1767
    if(strchr(address, ':') != NULL){
 
1768
      af = AF_INET6;
 
1769
    } else {
 
1770
      af = AF_INET;
 
1771
    }
 
1772
    
 
1773
    if(quit_now){
 
1774
      goto end;
 
1775
    }
 
1776
 
 
1777
    while(not quit_now){
 
1778
      ret = start_mandos_communication(address, port, if_index, af);
 
1779
      if(quit_now or ret == 0){
 
1780
        break;
 
1781
      }
 
1782
      sleep((int)retry_interval or 1);
 
1783
    };
 
1784
 
 
1785
    if (not quit_now){
 
1786
      exitcode = EXIT_SUCCESS;
 
1787
    }
 
1788
 
 
1789
    goto end;
 
1790
  }
 
1791
  
 
1792
  if(quit_now){
 
1793
    goto end;
 
1794
  }
 
1795
  
 
1796
  {
 
1797
    AvahiServerConfig config;
 
1798
    /* Do not publish any local Zeroconf records */
 
1799
    avahi_server_config_init(&config);
 
1800
    config.publish_hinfo = 0;
 
1801
    config.publish_addresses = 0;
 
1802
    config.publish_workstation = 0;
 
1803
    config.publish_domain = 0;
 
1804
    
 
1805
    /* Allocate a new server */
 
1806
    mc.server = avahi_server_new(avahi_simple_poll_get
 
1807
                                 (mc.simple_poll), &config, NULL,
 
1808
                                 NULL, &error);
 
1809
    
 
1810
    /* Free the Avahi configuration data */
 
1811
    avahi_server_config_free(&config);
 
1812
  }
 
1813
  
 
1814
  /* Check if creating the Avahi server object succeeded */
 
1815
  if(mc.server == NULL){
 
1816
    fprintf(stderr, "Failed to create Avahi server: %s\n",
 
1817
            avahi_strerror(error));
 
1818
    exitcode = EX_UNAVAILABLE;
 
1819
    goto end;
 
1820
  }
 
1821
  
 
1822
  if(quit_now){
 
1823
    goto end;
 
1824
  }
 
1825
  
 
1826
  /* Create the Avahi service browser */
 
1827
  sb = avahi_s_service_browser_new(mc.server, if_index,
 
1828
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
 
1829
                                   NULL, 0, browse_callback, NULL);
 
1830
  if(sb == NULL){
 
1831
    fprintf(stderr, "Failed to create service browser: %s\n",
 
1832
            avahi_strerror(avahi_server_errno(mc.server)));
 
1833
    exitcode = EX_UNAVAILABLE;
 
1834
    goto end;
 
1835
  }
 
1836
  
 
1837
  if(quit_now){
 
1838
    goto end;
 
1839
  }
 
1840
  
 
1841
  /* Run the main loop */
 
1842
  
 
1843
  if(debug){
 
1844
    fprintf(stderr, "Starting Avahi loop search\n");
 
1845
  }
 
1846
 
 
1847
  ret = avahi_loop_with_timeout(mc.simple_poll, (int)(retry_interval * 1000));
 
1848
  if(debug){
 
1849
    fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
 
1850
            (ret == 0) ? "successfully" : "with error");
 
1851
  }
 
1852
  
 
1853
 end:
 
1854
  
 
1855
  if(debug){
 
1856
    fprintf(stderr, "%s exiting\n", argv[0]);
 
1857
  }
 
1858
  
 
1859
  /* Cleanup things */
 
1860
  if(sb != NULL)
 
1861
    avahi_s_service_browser_free(sb);
 
1862
  
 
1863
  if(mc.server != NULL)
 
1864
    avahi_server_free(mc.server);
 
1865
  
 
1866
  if(mc.simple_poll != NULL)
 
1867
    avahi_simple_poll_free(mc.simple_poll);
 
1868
  
 
1869
  if(gnutls_initialized){
 
1870
    gnutls_certificate_free_credentials(mc.cred);
 
1871
    gnutls_global_deinit();
 
1872
    gnutls_dh_params_deinit(mc.dh_params);
 
1873
  }
 
1874
  
 
1875
  if(gpgme_initialized){
 
1876
    gpgme_release(mc.ctx);
 
1877
  }
 
1878
 
 
1879
  /* cleans up the circular linked list of mandos servers the client has seen */
 
1880
  if(mc.current_server != NULL){
 
1881
    mc.current_server->prev->next = NULL;
 
1882
    while(mc.current_server != NULL){
 
1883
      server *next = mc.current_server->next;
 
1884
      free(mc.current_server);
 
1885
      mc.current_server = next;
 
1886
    }
 
1887
  }
 
1888
  
 
1889
  /* Take down the network interface */
 
1890
  if(take_down_interface){
 
1891
    /* Re-raise priviliges */
 
1892
    errno = 0;
 
1893
    ret = seteuid(0);
 
1894
    if(ret == -1){
 
1895
      perror_plus("seteuid");
 
1896
    }
 
1897
    if(geteuid() == 0){
 
1898
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
1899
      if(ret == -1){
 
1900
        perror_plus("ioctl SIOCGIFFLAGS");
 
1901
      } else if(network.ifr_flags & IFF_UP) {
 
1902
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1903
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1904
        if(ret == -1){
 
1905
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1906
        }
 
1907
      }
 
1908
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1909
      if(ret == -1){
 
1910
        perror_plus("close");
 
1911
      }
 
1912
      /* Lower privileges permanently */
 
1913
      errno = 0;
 
1914
      ret = setuid(uid);
 
1915
      if(ret == -1){
 
1916
        perror_plus("setuid");
 
1917
      }
 
1918
    }
 
1919
  }
 
1920
  
 
1921
  /* Removes the GPGME temp directory and all files inside */
 
1922
  if(tempdir_created){
 
1923
    struct dirent **direntries = NULL;
 
1924
    struct dirent *direntry = NULL;
 
1925
    ret = scandir(tempdir, &direntries, notdotentries, alphasort);
 
1926
    if (ret > 0){
 
1927
      for(int i = 0; i < ret; i++){
 
1928
        direntry = direntries[i];
 
1929
        char *fullname = NULL;
 
1930
        ret = asprintf(&fullname, "%s/%s", tempdir,
 
1931
                       direntry->d_name);
 
1932
        if(ret < 0){
 
1933
          perror_plus("asprintf");
 
1934
          continue;
 
1935
        }
 
1936
        ret = remove(fullname);
 
1937
        if(ret == -1){
 
1938
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
 
1939
                  strerror(errno));
 
1940
        }
 
1941
        free(fullname);
 
1942
      }
 
1943
    }
 
1944
 
 
1945
    /* need to be cleaned even if ret == 0 because man page dont specify */
 
1946
    free(direntries);
 
1947
    if (ret == -1){
 
1948
      perror_plus("scandir");
 
1949
    }
 
1950
    ret = rmdir(tempdir);
 
1951
    if(ret == -1 and errno != ENOENT){
 
1952
      perror_plus("rmdir");
 
1953
    }
 
1954
  }
 
1955
  
 
1956
  if(quit_now){
 
1957
    sigemptyset(&old_sigterm_action.sa_mask);
 
1958
    old_sigterm_action.sa_handler = SIG_DFL;
 
1959
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
 
1960
                                            &old_sigterm_action,
 
1961
                                            NULL));
 
1962
    if(ret == -1){
 
1963
      perror_plus("sigaction");
 
1964
    }
 
1965
    do {
 
1966
      ret = raise(signal_received);
 
1967
    } while(ret != 0 and errno == EINTR);
 
1968
    if(ret != 0){
 
1969
      perror_plus("raise");
 
1970
      abort();
 
1971
    }
 
1972
    TEMP_FAILURE_RETRY(pause());
 
1973
  }
 
1974
  
 
1975
  return exitcode;
 
1976
}