/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

* plugin-runner.c: Comment change.

* plugins.d/mandos-client.c: Comment changes.
  (quit_now): New global flag.
  (handle_sigterm): Only call avahi_simple_poll_quit once.
  (main): Also handle SIGINT and SIGHUP.

Show diffs side-by-side

added added

removed removed

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