/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2011-07-13 02:24:39 UTC
  • mfrom: (24.1.174 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20110713022439-wbv6kghshdsc2x24
Merge from Björn.

Show diffs side-by-side

added added

removed removed

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