/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: 2015-05-23 20:18:34 UTC
  • mto: This revision was merged to the branch mainline in revision 756.
  • Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.

For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished".  This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found.  One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD.  To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous).  In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.

This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.

DBUS-API (CheckerCompleted): Change the second value provided by this
                             D-Bus signal from the raw wait(2) status
                             to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
                               multiprocessing.Process (starting a
                               separate process).
(Client.last_checker signal): New attribute for signal which
                              terminated last checker.  Like
                              last_checker_status, only not accessible
                              via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
                           to get returncode; set last_checker_signal.
                           Return False so gobject does not call this
                           callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
                        instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument.        Call
                               Client.checker_callback early to have
                               it set last_checker_status and
                               last_checker_signal; use those.  Change
                               second value provided to D-Bus signal
                               CheckerCompleted to use
                               last_checker_signal if checker was
                               terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
                                        "condition" argument.  Use it
                                        accordingly.  Remove dead code
                                        (os.WCOREDUMP case).

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2011 Teddy Hogeborn
13
 
 * Copyright © 2008-2011 Björn Påhlsson
 
12
 * Copyright © 2008-2014 Teddy Hogeborn
 
13
 * Copyright © 2008-2014 Björn Påhlsson
14
14
 * 
15
15
 * This program is free software: you can redistribute it and/or
16
16
 * modify it under the terms of the GNU General Public License as
26
26
 * along with this program.  If not, see
27
27
 * <http://www.gnu.org/licenses/>.
28
28
 * 
29
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
29
 * Contact the authors at <mandos@recompile.se>.
30
30
 */
31
31
 
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
 
#endif
 
35
#endif  /* not _LARGEFILE_SOURCE */
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
 
#endif
 
38
#endif  /* not _FILE_OFFSET_BITS */
39
39
 
40
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
 
42
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
 
43
                                   stdout, ferror() */
 
44
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
45
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
47
                                   strtof(), abort() */
53
53
                                   sockaddr_in6, PF_INET6,
54
54
                                   SOCK_STREAM, uid_t, gid_t, open(),
55
55
                                   opendir(), DIR */
56
 
#include <sys/stat.h>           /* open() */
 
56
#include <sys/stat.h>           /* open(), S_ISREG */
57
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
 
58
                                   inet_pton(), connect(),
 
59
                                   getnameinfo() */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
60
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
62
                                 */
62
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
63
64
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
65
#include <errno.h>              /* perror(), errno,
66
66
                                   program_invocation_short_name */
67
67
#include <time.h>               /* nanosleep(), time(), sleep() */
73
73
                                */
74
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
75
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause() */
77
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
76
                                   setgid(), pause(), _exit(),
 
77
                                   unlinkat() */
 
78
#include <arpa/inet.h>          /* inet_pton(), htons() */
78
79
#include <iso646.h>             /* not, or, and */
79
80
#include <argp.h>               /* struct argp_option, error_t, struct
80
81
                                   argp_state, struct argp,
85
86
                                   raise() */
86
87
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
88
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
 
89
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
 
90
                                   WEXITSTATUS(), WTERMSIG() */
 
91
#include <grp.h>                /* setgroups() */
 
92
#include <argz.h>               /* argz_add_sep(), argz_next(),
 
93
                                   argz_delete(), argz_append(),
 
94
                                   argz_stringify(), argz_add(),
 
95
                                   argz_count() */
 
96
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
97
                                   EAI_SYSTEM, gai_strerror() */
88
98
 
89
99
#ifdef __linux__
90
100
#include <sys/klog.h>           /* klogctl() */
108
118
                                   init_gnutls_session(),
109
119
                                   GNUTLS_* */
110
120
#include <gnutls/openpgp.h>
111
 
                          /* gnutls_certificate_set_openpgp_key_file(),
112
 
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
121
                         /* gnutls_certificate_set_openpgp_key_file(),
 
122
                            GNUTLS_OPENPGP_FMT_BASE64 */
113
123
 
114
124
/* GPGME */
115
125
#include <gpgme.h>              /* All GPGME types, constants and
123
133
#define PATHDIR "/conf/conf.d/mandos"
124
134
#define SECKEY "seckey.txt"
125
135
#define PUBKEY "pubkey.txt"
 
136
#define HOOKDIR "/lib/mandos/network-hooks.d"
126
137
 
127
138
bool debug = false;
128
139
static const char mandos_protocol_version[] = "1";
129
140
const char *argp_program_version = "mandos-client " VERSION;
130
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
141
const char *argp_program_bug_address = "<mandos@recompile.se>";
131
142
static const char sys_class_net[] = "/sys/class/net";
132
143
char *connect_to = NULL;
 
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
 
146
uid_t uid = 65534;
 
147
gid_t gid = 65534;
133
148
 
134
149
/* Doubly linked list that need to be circularly linked when used */
135
150
typedef struct server{
136
151
  const char *ip;
137
 
  uint16_t port;
 
152
  in_port_t port;
138
153
  AvahiIfIndex if_index;
139
154
  int af;
140
155
  struct timespec last_seen;
144
159
 
145
160
/* Used for passing in values through the Avahi callback functions */
146
161
typedef struct {
147
 
  AvahiSimplePoll *simple_poll;
148
162
  AvahiServer *server;
149
163
  gnutls_certificate_credentials_t cred;
150
164
  unsigned int dh_bits;
152
166
  const char *priority;
153
167
  gpgme_ctx_t ctx;
154
168
  server *current_server;
 
169
  char *interfaces;
 
170
  size_t interfaces_size;
155
171
} mandos_context;
156
172
 
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 };
 
173
/* global so signal handler can reach it*/
 
174
AvahiSimplePoll *simple_poll;
162
175
 
163
176
sig_atomic_t quit_now = 0;
164
177
int signal_received = 0;
165
178
 
166
179
/* Function to use when printing errors */
167
180
void perror_plus(const char *print_text){
 
181
  int e = errno;
168
182
  fprintf(stderr, "Mandos plugin %s: ",
169
183
          program_invocation_short_name);
 
184
  errno = e;
170
185
  perror(print_text);
171
186
}
172
187
 
 
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
 
189
int fprintf_plus(FILE *stream, const char *format, ...){
 
190
  va_list ap;
 
191
  va_start (ap, format);
 
192
  
 
193
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
 
194
                             program_invocation_short_name));
 
195
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
196
}
 
197
 
173
198
/*
174
199
 * Make additional room in "buffer" for at least BUFFER_SIZE more
175
200
 * bytes. "buffer_capacity" is how much is currently allocated,
176
201
 * "buffer_length" is how much is already used.
177
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
178
204
size_t incbuffer(char **buffer, size_t buffer_length,
179
 
                  size_t buffer_capacity){
 
205
                 size_t buffer_capacity){
180
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
181
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
182
 
    if(buffer == NULL){
 
207
    char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
208
    if(new_buf == NULL){
 
209
      int old_errno = errno;
 
210
      free(*buffer);
 
211
      errno = old_errno;
 
212
      *buffer = NULL;
183
213
      return 0;
184
214
    }
 
215
    *buffer = new_buf;
185
216
    buffer_capacity += BUFFER_SIZE;
186
217
  }
187
218
  return buffer_capacity;
188
219
}
189
220
 
190
221
/* Add server to set of servers to retry periodically */
191
 
int add_server(const char *ip, uint16_t port,
192
 
                 AvahiIfIndex if_index,
193
 
                 int af){
 
222
__attribute__((nonnull, warn_unused_result))
 
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
224
                int af, server **current_server){
194
225
  int ret;
195
226
  server *new_server = malloc(sizeof(server));
196
227
  if(new_server == NULL){
197
228
    perror_plus("malloc");
198
 
    return -1;
 
229
    return false;
199
230
  }
200
231
  *new_server = (server){ .ip = strdup(ip),
201
 
                         .port = port,
202
 
                         .if_index = if_index,
203
 
                         .af = af };
 
232
                          .port = port,
 
233
                          .if_index = if_index,
 
234
                          .af = af };
204
235
  if(new_server->ip == NULL){
205
236
    perror_plus("strdup");
206
 
    return -1;
 
237
    free(new_server);
 
238
    return false;
 
239
  }
 
240
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
 
241
  if(ret == -1){
 
242
    perror_plus("clock_gettime");
 
243
#ifdef __GNUC__
 
244
#pragma GCC diagnostic push
 
245
#pragma GCC diagnostic ignored "-Wcast-qual"
 
246
#endif
 
247
    free((char *)(new_server->ip));
 
248
#ifdef __GNUC__
 
249
#pragma GCC diagnostic pop
 
250
#endif
 
251
    free(new_server);
 
252
    return false;
207
253
  }
208
254
  /* Special case of first server */
209
 
  if (mc.current_server == NULL){
 
255
  if(*current_server == NULL){
210
256
    new_server->next = new_server;
211
257
    new_server->prev = new_server;
212
 
    mc.current_server = new_server;
213
 
  /* Place the new server last in the list */
 
258
    *current_server = new_server;
214
259
  } else {
215
 
    new_server->next = mc.current_server;
216
 
    new_server->prev = mc.current_server->prev;
 
260
    /* Place the new server last in the list */
 
261
    new_server->next = *current_server;
 
262
    new_server->prev = (*current_server)->prev;
217
263
    new_server->prev->next = new_server;
218
 
    mc.current_server->prev = new_server;
219
 
  }
220
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
221
 
  if(ret == -1){
222
 
    perror_plus("clock_gettime");
223
 
    return -1;
224
 
  }
225
 
  return 0;
 
264
    (*current_server)->prev = new_server;
 
265
  }
 
266
  return true;
226
267
}
227
268
 
228
269
/* 
229
270
 * Initialize GPGME.
230
271
 */
231
 
static bool init_gpgme(const char *seckey,
232
 
                       const char *pubkey, const char *tempdir){
 
272
__attribute__((nonnull, warn_unused_result))
 
273
static bool init_gpgme(const char * const seckey,
 
274
                       const char * const pubkey,
 
275
                       const char * const tempdir,
 
276
                       mandos_context *mc){
233
277
  gpgme_error_t rc;
234
278
  gpgme_engine_info_t engine_info;
235
279
  
236
 
  
237
280
  /*
238
281
   * Helper function to insert pub and seckey to the engine keyring.
239
282
   */
240
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
241
284
    int ret;
242
285
    int fd;
243
286
    gpgme_data_t pgp_data;
250
293
    
251
294
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
252
295
    if(rc != GPG_ERR_NO_ERROR){
253
 
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
254
 
              gpgme_strsource(rc), gpgme_strerror(rc));
 
296
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
297
                   gpgme_strsource(rc), gpgme_strerror(rc));
255
298
      return false;
256
299
    }
257
300
    
258
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
301
    rc = gpgme_op_import(mc->ctx, pgp_data);
259
302
    if(rc != GPG_ERR_NO_ERROR){
260
 
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
261
 
              gpgme_strsource(rc), gpgme_strerror(rc));
 
303
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
 
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
262
305
      return false;
263
306
    }
264
307
    
271
314
  }
272
315
  
273
316
  if(debug){
274
 
    fprintf(stderr, "Initializing GPGME\n");
 
317
    fprintf_plus(stderr, "Initializing GPGME\n");
275
318
  }
276
319
  
277
320
  /* Init GPGME */
278
321
  gpgme_check_version(NULL);
279
322
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
280
323
  if(rc != GPG_ERR_NO_ERROR){
281
 
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
282
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
324
    fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
325
                 gpgme_strsource(rc), gpgme_strerror(rc));
283
326
    return false;
284
327
  }
285
328
  
286
329
  /* Set GPGME home directory for the OpenPGP engine only */
287
330
  rc = gpgme_get_engine_info(&engine_info);
288
331
  if(rc != GPG_ERR_NO_ERROR){
289
 
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
290
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
332
    fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
333
                 gpgme_strsource(rc), gpgme_strerror(rc));
291
334
    return false;
292
335
  }
293
336
  while(engine_info != NULL){
299
342
    engine_info = engine_info->next;
300
343
  }
301
344
  if(engine_info == NULL){
302
 
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
345
    fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
 
346
                 tempdir);
303
347
    return false;
304
348
  }
305
349
  
306
350
  /* Create new GPGME "context" */
307
 
  rc = gpgme_new(&(mc.ctx));
 
351
  rc = gpgme_new(&(mc->ctx));
308
352
  if(rc != GPG_ERR_NO_ERROR){
309
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
310
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
353
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
354
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
 
355
                 gpgme_strerror(rc));
311
356
    return false;
312
357
  }
313
358
  
322
367
 * Decrypt OpenPGP data.
323
368
 * Returns -1 on error
324
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
325
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
326
372
                                  size_t crypto_size,
327
 
                                  char **plaintext){
 
373
                                  char **plaintext,
 
374
                                  mandos_context *mc){
328
375
  gpgme_data_t dh_crypto, dh_plain;
329
376
  gpgme_error_t rc;
330
377
  ssize_t ret;
332
379
  ssize_t plaintext_length = 0;
333
380
  
334
381
  if(debug){
335
 
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
382
    fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
336
383
  }
337
384
  
338
385
  /* Create new GPGME data buffer from memory cryptotext */
339
386
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
340
387
                               0);
341
388
  if(rc != GPG_ERR_NO_ERROR){
342
 
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
343
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
389
    fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
390
                 gpgme_strsource(rc), gpgme_strerror(rc));
344
391
    return -1;
345
392
  }
346
393
  
347
394
  /* Create new empty GPGME data buffer for the plaintext */
348
395
  rc = gpgme_data_new(&dh_plain);
349
396
  if(rc != GPG_ERR_NO_ERROR){
350
 
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
351
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
397
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
398
                 "bad gpgme_data_new: %s: %s\n",
 
399
                 gpgme_strsource(rc), gpgme_strerror(rc));
352
400
    gpgme_data_release(dh_crypto);
353
401
    return -1;
354
402
  }
355
403
  
356
404
  /* Decrypt data from the cryptotext data buffer to the plaintext
357
405
     data buffer */
358
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
406
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
359
407
  if(rc != GPG_ERR_NO_ERROR){
360
 
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
361
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
408
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
409
                 gpgme_strsource(rc), gpgme_strerror(rc));
362
410
    plaintext_length = -1;
363
411
    if(debug){
364
412
      gpgme_decrypt_result_t result;
365
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
413
      result = gpgme_op_decrypt_result(mc->ctx);
366
414
      if(result == NULL){
367
 
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
368
416
      } else {
369
 
        fprintf(stderr, "Unsupported algorithm: %s\n",
370
 
                result->unsupported_algorithm);
371
 
        fprintf(stderr, "Wrong key usage: %u\n",
372
 
                result->wrong_key_usage);
 
417
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
418
                     result->unsupported_algorithm);
 
419
        fprintf_plus(stderr, "Wrong key usage: %u\n",
 
420
                     result->wrong_key_usage);
373
421
        if(result->file_name != NULL){
374
 
          fprintf(stderr, "File name: %s\n", result->file_name);
 
422
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
375
423
        }
376
424
        gpgme_recipient_t recipient;
377
425
        recipient = result->recipients;
378
426
        while(recipient != NULL){
379
 
          fprintf(stderr, "Public key algorithm: %s\n",
380
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
381
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
382
 
          fprintf(stderr, "Secret key available: %s\n",
383
 
                  recipient->status == GPG_ERR_NO_SECKEY
384
 
                  ? "No" : "Yes");
 
427
          fprintf_plus(stderr, "Public key algorithm: %s\n",
 
428
                       gpgme_pubkey_algo_name
 
429
                       (recipient->pubkey_algo));
 
430
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
431
          fprintf_plus(stderr, "Secret key available: %s\n",
 
432
                       recipient->status == GPG_ERR_NO_SECKEY
 
433
                       ? "No" : "Yes");
385
434
          recipient = recipient->next;
386
435
        }
387
436
      }
390
439
  }
391
440
  
392
441
  if(debug){
393
 
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
442
    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
394
443
  }
395
444
  
396
445
  /* Seek back to the beginning of the GPGME plaintext data buffer */
403
452
  *plaintext = NULL;
404
453
  while(true){
405
454
    plaintext_capacity = incbuffer(plaintext,
406
 
                                      (size_t)plaintext_length,
407
 
                                      plaintext_capacity);
 
455
                                   (size_t)plaintext_length,
 
456
                                   plaintext_capacity);
408
457
    if(plaintext_capacity == 0){
409
 
        perror_plus("incbuffer");
410
 
        plaintext_length = -1;
411
 
        goto decrypt_end;
 
458
      perror_plus("incbuffer");
 
459
      plaintext_length = -1;
 
460
      goto decrypt_end;
412
461
    }
413
462
    
414
463
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
427
476
  }
428
477
  
429
478
  if(debug){
430
 
    fprintf(stderr, "Decrypted password is: ");
 
479
    fprintf_plus(stderr, "Decrypted password is: ");
431
480
    for(ssize_t i = 0; i < plaintext_length; i++){
432
481
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
433
482
    }
444
493
  return plaintext_length;
445
494
}
446
495
 
447
 
static const char * safer_gnutls_strerror(int value){
448
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
449
 
                                               -Wunreachable-code */
450
 
  if(ret == NULL)
451
 
    ret = "(unknown)";
452
 
  return ret;
 
496
__attribute__((warn_unused_result, const))
 
497
static const char *safe_string(const char *str){
 
498
  if(str == NULL)
 
499
    return "(unknown)";
 
500
  return str;
 
501
}
 
502
 
 
503
__attribute__((warn_unused_result))
 
504
static const char *safer_gnutls_strerror(int value){
 
505
  const char *ret = gnutls_strerror(value);
 
506
  return safe_string(ret);
453
507
}
454
508
 
455
509
/* GnuTLS log function callback */
 
510
__attribute__((nonnull))
456
511
static void debuggnutls(__attribute__((unused)) int level,
457
512
                        const char* string){
458
 
  fprintf(stderr, "GnuTLS: %s", string);
 
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
459
514
}
460
515
 
 
516
__attribute__((nonnull, warn_unused_result))
461
517
static int init_gnutls_global(const char *pubkeyfilename,
462
 
                              const char *seckeyfilename){
 
518
                              const char *seckeyfilename,
 
519
                              mandos_context *mc){
463
520
  int ret;
 
521
  unsigned int uret;
464
522
  
465
523
  if(debug){
466
 
    fprintf(stderr, "Initializing GnuTLS\n");
 
524
    fprintf_plus(stderr, "Initializing GnuTLS\n");
467
525
  }
468
526
  
469
527
  ret = gnutls_global_init();
470
528
  if(ret != GNUTLS_E_SUCCESS){
471
 
    fprintf(stderr, "GnuTLS global_init: %s\n",
472
 
            safer_gnutls_strerror(ret));
 
529
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
530
                 safer_gnutls_strerror(ret));
473
531
    return -1;
474
532
  }
475
533
  
482
540
  }
483
541
  
484
542
  /* OpenPGP credentials */
485
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
543
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
486
544
  if(ret != GNUTLS_E_SUCCESS){
487
 
    fprintf(stderr, "GnuTLS memory error: %s\n",
488
 
            safer_gnutls_strerror(ret));
 
545
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
 
546
                 safer_gnutls_strerror(ret));
489
547
    gnutls_global_deinit();
490
548
    return -1;
491
549
  }
492
550
  
493
551
  if(debug){
494
 
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
495
 
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
496
 
            seckeyfilename);
 
552
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
553
                 " secret key %s as GnuTLS credentials\n",
 
554
                 pubkeyfilename,
 
555
                 seckeyfilename);
497
556
  }
498
557
  
499
558
  ret = gnutls_certificate_set_openpgp_key_file
500
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
559
    (mc->cred, pubkeyfilename, seckeyfilename,
501
560
     GNUTLS_OPENPGP_FMT_BASE64);
502
561
  if(ret != GNUTLS_E_SUCCESS){
503
 
    fprintf(stderr,
504
 
            "Error[%d] while reading the OpenPGP key pair ('%s',"
505
 
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
506
 
    fprintf(stderr, "The GnuTLS error is: %s\n",
507
 
            safer_gnutls_strerror(ret));
 
562
    fprintf_plus(stderr,
 
563
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
564
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
565
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
 
566
                 safer_gnutls_strerror(ret));
508
567
    goto globalfail;
509
568
  }
510
569
  
511
570
  /* GnuTLS server initialization */
512
 
  ret = gnutls_dh_params_init(&mc.dh_params);
 
571
  ret = gnutls_dh_params_init(&mc->dh_params);
513
572
  if(ret != GNUTLS_E_SUCCESS){
514
 
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
515
 
            " %s\n", safer_gnutls_strerror(ret));
 
573
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
 
574
                 " initialization: %s\n",
 
575
                 safer_gnutls_strerror(ret));
516
576
    goto globalfail;
517
577
  }
518
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
578
  if(mc->dh_bits == 0){
 
579
    /* Find out the optimal number of DH bits */
 
580
    /* Try to read the private key file */
 
581
    gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
582
    {
 
583
      int secfile = open(seckeyfilename, O_RDONLY);
 
584
      size_t buffer_capacity = 0;
 
585
      while(true){
 
586
        buffer_capacity = incbuffer((char **)&buffer.data,
 
587
                                    (size_t)buffer.size,
 
588
                                    (size_t)buffer_capacity);
 
589
        if(buffer_capacity == 0){
 
590
          perror_plus("incbuffer");
 
591
          free(buffer.data);
 
592
          buffer.data = NULL;
 
593
          break;
 
594
        }
 
595
        ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
 
596
                                  BUFFER_SIZE);
 
597
        /* EOF */
 
598
        if(bytes_read == 0){
 
599
          break;
 
600
        }
 
601
        /* check bytes_read for failure */
 
602
        if(bytes_read < 0){
 
603
          perror_plus("read");
 
604
          free(buffer.data);
 
605
          buffer.data = NULL;
 
606
          break;
 
607
        }
 
608
        buffer.size += (unsigned int)bytes_read;
 
609
      }
 
610
      close(secfile);
 
611
    }
 
612
    /* If successful, use buffer to parse private key */
 
613
    gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
614
    if(buffer.data != NULL){
 
615
      {
 
616
        gnutls_openpgp_privkey_t privkey = NULL;
 
617
        ret = gnutls_openpgp_privkey_init(&privkey);
 
618
        if(ret != GNUTLS_E_SUCCESS){
 
619
          fprintf_plus(stderr, "Error initializing OpenPGP key"
 
620
                       " structure: %s", safer_gnutls_strerror(ret));
 
621
          free(buffer.data);
 
622
          buffer.data = NULL;
 
623
        } else {
 
624
          ret = gnutls_openpgp_privkey_import(privkey, &buffer,
 
625
                                            GNUTLS_OPENPGP_FMT_BASE64,
 
626
                                              "", 0);
 
627
          if(ret != GNUTLS_E_SUCCESS){
 
628
            fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
629
                         safer_gnutls_strerror(ret));
 
630
            privkey = NULL;
 
631
          }
 
632
          free(buffer.data);
 
633
          buffer.data = NULL;
 
634
          if(privkey != NULL){
 
635
            /* Use private key to suggest an appropriate sec_param */
 
636
            sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
637
            gnutls_openpgp_privkey_deinit(privkey);
 
638
            if(debug){
 
639
              fprintf_plus(stderr, "This OpenPGP key implies using a"
 
640
                           " GnuTLS security parameter \"%s\".\n",
 
641
                           safe_string(gnutls_sec_param_get_name
 
642
                                       (sec_param)));
 
643
            }
 
644
          }
 
645
        }
 
646
      }
 
647
      if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
648
        /* Err on the side of caution */
 
649
        sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
650
        if(debug){
 
651
          fprintf_plus(stderr, "Falling back to security parameter"
 
652
                       " \"%s\"\n",
 
653
                       safe_string(gnutls_sec_param_get_name
 
654
                                   (sec_param)));
 
655
        }
 
656
      }
 
657
    }
 
658
    uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
659
    if(uret != 0){
 
660
      mc->dh_bits = uret;
 
661
      if(debug){
 
662
        fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
663
                     " implies %u DH bits; using that.\n",
 
664
                     safe_string(gnutls_sec_param_get_name
 
665
                                 (sec_param)),
 
666
                     mc->dh_bits);
 
667
      }
 
668
    } else {
 
669
      fprintf_plus(stderr, "Failed to get implied number of DH"
 
670
                   " bits for security parameter \"%s\"): %s\n",
 
671
                   safe_string(gnutls_sec_param_get_name(sec_param)),
 
672
                   safer_gnutls_strerror(ret));
 
673
      goto globalfail;
 
674
    }
 
675
  } else if(debug){
 
676
    fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
677
                 mc->dh_bits);
 
678
  }
 
679
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
519
680
  if(ret != GNUTLS_E_SUCCESS){
520
 
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
521
 
            safer_gnutls_strerror(ret));
 
681
    fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
 
682
                 " %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
522
683
    goto globalfail;
523
684
  }
524
685
  
525
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
686
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
526
687
  
527
688
  return 0;
528
689
  
529
690
 globalfail:
530
691
  
531
 
  gnutls_certificate_free_credentials(mc.cred);
 
692
  gnutls_certificate_free_credentials(mc->cred);
532
693
  gnutls_global_deinit();
533
 
  gnutls_dh_params_deinit(mc.dh_params);
 
694
  gnutls_dh_params_deinit(mc->dh_params);
534
695
  return -1;
535
696
}
536
697
 
537
 
static int init_gnutls_session(gnutls_session_t *session){
 
698
__attribute__((nonnull, warn_unused_result))
 
699
static int init_gnutls_session(gnutls_session_t *session,
 
700
                               mandos_context *mc){
538
701
  int ret;
539
702
  /* GnuTLS session creation */
540
703
  do {
544
707
    }
545
708
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
546
709
  if(ret != GNUTLS_E_SUCCESS){
547
 
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
548
 
            safer_gnutls_strerror(ret));
 
710
    fprintf_plus(stderr,
 
711
                 "Error in GnuTLS session initialization: %s\n",
 
712
                 safer_gnutls_strerror(ret));
549
713
  }
550
714
  
551
715
  {
552
716
    const char *err;
553
717
    do {
554
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
718
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
555
719
      if(quit_now){
556
720
        gnutls_deinit(*session);
557
721
        return -1;
558
722
      }
559
723
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
560
724
    if(ret != GNUTLS_E_SUCCESS){
561
 
      fprintf(stderr, "Syntax error at: %s\n", err);
562
 
      fprintf(stderr, "GnuTLS error: %s\n",
563
 
              safer_gnutls_strerror(ret));
 
725
      fprintf_plus(stderr, "Syntax error at: %s\n", err);
 
726
      fprintf_plus(stderr, "GnuTLS error: %s\n",
 
727
                   safer_gnutls_strerror(ret));
564
728
      gnutls_deinit(*session);
565
729
      return -1;
566
730
    }
568
732
  
569
733
  do {
570
734
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
571
 
                                 mc.cred);
 
735
                                 mc->cred);
572
736
    if(quit_now){
573
737
      gnutls_deinit(*session);
574
738
      return -1;
575
739
    }
576
740
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
577
741
  if(ret != GNUTLS_E_SUCCESS){
578
 
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
579
 
            safer_gnutls_strerror(ret));
 
742
    fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
 
743
                 safer_gnutls_strerror(ret));
580
744
    gnutls_deinit(*session);
581
745
    return -1;
582
746
  }
584
748
  /* ignore client certificate if any. */
585
749
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
586
750
  
587
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
751
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
588
752
  
589
753
  return 0;
590
754
}
594
758
                      __attribute__((unused)) const char *txt){}
595
759
 
596
760
/* Called when a Mandos server is found */
597
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
761
__attribute__((nonnull, warn_unused_result))
 
762
static int start_mandos_communication(const char *ip, in_port_t port,
598
763
                                      AvahiIfIndex if_index,
599
 
                                      int af){
 
764
                                      int af, mandos_context *mc){
600
765
  int ret, tcp_sd = -1;
601
766
  ssize_t sret;
602
 
  union {
603
 
    struct sockaddr_in in;
604
 
    struct sockaddr_in6 in6;
605
 
  } to;
 
767
  struct sockaddr_storage to;
606
768
  char *buffer = NULL;
607
769
  char *decrypted_buffer = NULL;
608
770
  size_t buffer_length = 0;
627
789
    pf = PF_INET;
628
790
    break;
629
791
  default:
630
 
    fprintf(stderr, "Bad address family: %d\n", af);
 
792
    fprintf_plus(stderr, "Bad address family: %d\n", af);
631
793
    errno = EINVAL;
632
794
    return -1;
633
795
  }
634
796
  
635
 
  ret = init_gnutls_session(&session);
 
797
  /* If the interface is specified and we have a list of interfaces */
 
798
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
799
    /* Check if the interface is one of the interfaces we are using */
 
800
    bool match = false;
 
801
    {
 
802
      char *interface = NULL;
 
803
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
804
                                 interface))){
 
805
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
806
          match = true;
 
807
          break;
 
808
        }
 
809
      }
 
810
    }
 
811
    if(not match){
 
812
      /* This interface does not match any in the list, so we don't
 
813
         connect to the server */
 
814
      if(debug){
 
815
        char interface[IF_NAMESIZE];
 
816
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
817
          perror_plus("if_indextoname");
 
818
        } else {
 
819
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
820
                       " \"%s\"\n",
 
821
                       if_indextoname((unsigned int)if_index,
 
822
                                      interface));
 
823
        }
 
824
      }
 
825
      return -1;
 
826
    }
 
827
  }
 
828
  
 
829
  ret = init_gnutls_session(&session, mc);
636
830
  if(ret != 0){
637
831
    return -1;
638
832
  }
639
833
  
640
834
  if(debug){
641
 
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
642
 
            "\n", ip, port);
 
835
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
 
836
                 PRIuMAX "\n", ip, (uintmax_t)port);
643
837
  }
644
838
  
645
839
  tcp_sd = socket(pf, SOCK_STREAM, 0);
657
851
  
658
852
  memset(&to, 0, sizeof(to));
659
853
  if(af == AF_INET6){
660
 
    to.in6.sin6_family = (sa_family_t)af;
661
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
854
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
 
855
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
662
856
  } else {                      /* IPv4 */
663
 
    to.in.sin_family = (sa_family_t)af;
664
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
857
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
 
858
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
665
859
  }
666
860
  if(ret < 0 ){
667
861
    int e = errno;
671
865
  }
672
866
  if(ret == 0){
673
867
    int e = errno;
674
 
    fprintf(stderr, "Bad address: %s\n", ip);
 
868
    fprintf_plus(stderr, "Bad address: %s\n", ip);
675
869
    errno = e;
676
870
    goto mandos_end;
677
871
  }
678
872
  if(af == AF_INET6){
679
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
680
 
                                       -Wconversion and
681
 
                                       -Wunreachable-code */
682
 
    
683
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
684
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
685
 
                              -Wunreachable-code*/
 
873
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
874
    if(IN6_IS_ADDR_LINKLOCAL
 
875
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
686
876
      if(if_index == AVAHI_IF_UNSPEC){
687
 
        fprintf(stderr, "An IPv6 link-local address is incomplete"
688
 
                " without a network interface\n");
 
877
        fprintf_plus(stderr, "An IPv6 link-local address is"
 
878
                     " incomplete without a network interface\n");
689
879
        errno = EINVAL;
690
880
        goto mandos_end;
691
881
      }
692
882
      /* Set the network interface number as scope */
693
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
883
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
694
884
    }
695
885
  } else {
696
 
    to.in.sin_port = htons(port); /* Spurious warnings from
697
 
                                     -Wconversion and
698
 
                                     -Wunreachable-code */
 
886
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
699
887
  }
700
888
  
701
889
  if(quit_now){
709
897
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
710
898
        perror_plus("if_indextoname");
711
899
      } else {
712
 
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
713
 
                ip, interface, port);
 
900
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
901
                     "\n", ip, interface, (uintmax_t)port);
714
902
      }
715
903
    } else {
716
 
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
717
 
              port);
 
904
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
905
                   ip, (uintmax_t)port);
718
906
    }
719
907
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
720
908
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
721
 
    const char *pcret;
722
909
    if(af == AF_INET6){
723
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
724
 
                        sizeof(addrstr));
 
910
      ret = getnameinfo((struct sockaddr *)&to,
 
911
                        sizeof(struct sockaddr_in6),
 
912
                        addrstr, sizeof(addrstr), NULL, 0,
 
913
                        NI_NUMERICHOST);
725
914
    } else {
726
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
727
 
                        sizeof(addrstr));
 
915
      ret = getnameinfo((struct sockaddr *)&to,
 
916
                        sizeof(struct sockaddr_in),
 
917
                        addrstr, sizeof(addrstr), NULL, 0,
 
918
                        NI_NUMERICHOST);
728
919
    }
729
 
    if(pcret == NULL){
730
 
      perror_plus("inet_ntop");
731
 
    } else {
732
 
      if(strcmp(addrstr, ip) != 0){
733
 
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
734
 
      }
 
920
    if(ret == EAI_SYSTEM){
 
921
      perror_plus("getnameinfo");
 
922
    } else if(ret != 0) {
 
923
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
924
    } else if(strcmp(addrstr, ip) != 0){
 
925
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
735
926
    }
736
927
  }
737
928
  
741
932
  }
742
933
  
743
934
  if(af == AF_INET6){
744
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
935
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
936
                  sizeof(struct sockaddr_in6));
745
937
  } else {
746
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
938
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
939
                  sizeof(struct sockaddr_in));
747
940
  }
748
941
  if(ret < 0){
749
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
942
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
750
943
      int e = errno;
751
944
      perror_plus("connect");
752
945
      errno = e;
764
957
  while(true){
765
958
    size_t out_size = strlen(out);
766
959
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
767
 
                                   out_size - written));
 
960
                                        out_size - written));
768
961
    if(ret == -1){
769
962
      int e = errno;
770
963
      perror_plus("write");
790
983
  }
791
984
  
792
985
  if(debug){
793
 
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
986
    fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
794
987
  }
795
988
  
796
989
  if(quit_now){
798
991
    goto mandos_end;
799
992
  }
800
993
  
801
 
  /* Spurious warning from -Wint-to-pointer-cast */
802
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
994
  /* This casting via intptr_t is to eliminate warning about casting
 
995
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
996
     function "set-session-transport-fd!" does it. */
 
997
  gnutls_transport_set_ptr(session,
 
998
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
803
999
  
804
1000
  if(quit_now){
805
1001
    errno = EINTR;
816
1012
  
817
1013
  if(ret != GNUTLS_E_SUCCESS){
818
1014
    if(debug){
819
 
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
1015
      fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
820
1016
      gnutls_perror(ret);
821
1017
    }
822
1018
    errno = EPROTO;
826
1022
  /* Read OpenPGP packet that contains the wanted password */
827
1023
  
828
1024
  if(debug){
829
 
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
830
 
            ip);
 
1025
    fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
 
1026
                 " %s\n", ip);
831
1027
  }
832
1028
  
833
1029
  while(true){
838
1034
    }
839
1035
    
840
1036
    buffer_capacity = incbuffer(&buffer, buffer_length,
841
 
                                   buffer_capacity);
 
1037
                                buffer_capacity);
842
1038
    if(buffer_capacity == 0){
843
1039
      int e = errno;
844
1040
      perror_plus("incbuffer");
871
1067
          }
872
1068
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
873
1069
        if(ret < 0){
874
 
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
1070
          fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
 
1071
                       "***\n");
875
1072
          gnutls_perror(ret);
876
1073
          errno = EPROTO;
877
1074
          goto mandos_end;
878
1075
        }
879
1076
        break;
880
1077
      default:
881
 
        fprintf(stderr, "Unknown error while reading data from"
882
 
                " encrypted session with Mandos server\n");
 
1078
        fprintf_plus(stderr, "Unknown error while reading data from"
 
1079
                     " encrypted session with Mandos server\n");
883
1080
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
884
1081
        errno = EIO;
885
1082
        goto mandos_end;
890
1087
  }
891
1088
  
892
1089
  if(debug){
893
 
    fprintf(stderr, "Closing TLS session\n");
 
1090
    fprintf_plus(stderr, "Closing TLS session\n");
894
1091
  }
895
1092
  
896
1093
  if(quit_now){
908
1105
  
909
1106
  if(buffer_length > 0){
910
1107
    ssize_t decrypted_buffer_size;
911
 
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
912
 
                                               buffer_length,
913
 
                                               &decrypted_buffer);
 
1108
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
 
1109
                                               &decrypted_buffer, mc);
914
1110
    if(decrypted_buffer_size >= 0){
915
1111
      
916
1112
      written = 0;
926
1122
        if(ret == 0 and ferror(stdout)){
927
1123
          int e = errno;
928
1124
          if(debug){
929
 
            fprintf(stderr, "Error writing encrypted data: %s\n",
930
 
                    strerror(errno));
 
1125
            fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1126
                         strerror(errno));
931
1127
          }
932
1128
          errno = e;
933
1129
          goto mandos_end;
964
1160
  return retval;
965
1161
}
966
1162
 
 
1163
__attribute__((nonnull))
967
1164
static void resolve_callback(AvahiSServiceResolver *r,
968
1165
                             AvahiIfIndex interface,
969
1166
                             AvahiProtocol proto,
977
1174
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
978
1175
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
979
1176
                             flags,
980
 
                             AVAHI_GCC_UNUSED void* userdata){
981
 
  assert(r);
 
1177
                             void *mc){
 
1178
  if(r == NULL){
 
1179
    return;
 
1180
  }
982
1181
  
983
1182
  /* Called whenever a service has been resolved successfully or
984
1183
     timed out */
985
1184
  
986
1185
  if(quit_now){
 
1186
    avahi_s_service_resolver_free(r);
987
1187
    return;
988
1188
  }
989
1189
  
990
1190
  switch(event){
991
1191
  default:
992
1192
  case AVAHI_RESOLVER_FAILURE:
993
 
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
994
 
            " of type '%s' in domain '%s': %s\n", name, type, domain,
995
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
1193
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
 
1194
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
 
1195
                 domain,
 
1196
                 avahi_strerror(avahi_server_errno
 
1197
                                (((mandos_context*)mc)->server)));
996
1198
    break;
997
1199
    
998
1200
  case AVAHI_RESOLVER_FOUND:
1000
1202
      char ip[AVAHI_ADDRESS_STR_MAX];
1001
1203
      avahi_address_snprint(ip, sizeof(ip), address);
1002
1204
      if(debug){
1003
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
1004
 
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1005
 
                ip, (intmax_t)interface, port);
 
1205
        fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
1206
                     PRIdMAX ") on port %" PRIu16 "\n", name,
 
1207
                     host_name, ip, (intmax_t)interface, port);
1006
1208
      }
1007
 
      int ret = start_mandos_communication(ip, port, interface,
1008
 
                                           avahi_proto_to_af(proto));
 
1209
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1210
                                           interface,
 
1211
                                           avahi_proto_to_af(proto),
 
1212
                                           mc);
1009
1213
      if(ret == 0){
1010
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1214
        avahi_simple_poll_quit(simple_poll);
1011
1215
      } else {
1012
 
        ret = add_server(ip, port, interface,
1013
 
                         avahi_proto_to_af(proto));
 
1216
        if(not add_server(ip, (in_port_t)port, interface,
 
1217
                          avahi_proto_to_af(proto),
 
1218
                          &((mandos_context*)mc)->current_server)){
 
1219
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1220
                       " list\n", name);
 
1221
        }
1014
1222
      }
1015
1223
    }
1016
1224
  }
1026
1234
                            const char *domain,
1027
1235
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1028
1236
                            flags,
1029
 
                            AVAHI_GCC_UNUSED void* userdata){
1030
 
  assert(b);
 
1237
                            void *mc){
 
1238
  if(b == NULL){
 
1239
    return;
 
1240
  }
1031
1241
  
1032
1242
  /* Called whenever a new services becomes available on the LAN or
1033
1243
     is removed from the LAN */
1040
1250
  default:
1041
1251
  case AVAHI_BROWSER_FAILURE:
1042
1252
    
1043
 
    fprintf(stderr, "(Avahi browser) %s\n",
1044
 
            avahi_strerror(avahi_server_errno(mc.server)));
1045
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1253
    fprintf_plus(stderr, "(Avahi browser) %s\n",
 
1254
                 avahi_strerror(avahi_server_errno
 
1255
                                (((mandos_context*)mc)->server)));
 
1256
    avahi_simple_poll_quit(simple_poll);
1046
1257
    return;
1047
1258
    
1048
1259
  case AVAHI_BROWSER_NEW:
1051
1262
       the callback function is called the Avahi server will free the
1052
1263
       resolver for us. */
1053
1264
    
1054
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1055
 
                                    name, type, domain, protocol, 0,
1056
 
                                    resolve_callback, NULL) == NULL)
1057
 
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
1058
 
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
1265
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1266
                                    interface, protocol, name, type,
 
1267
                                    domain, protocol, 0,
 
1268
                                    resolve_callback, mc) == NULL)
 
1269
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
 
1270
                   " %s\n", name,
 
1271
                   avahi_strerror(avahi_server_errno
 
1272
                                  (((mandos_context*)mc)->server)));
1059
1273
    break;
1060
1274
    
1061
1275
  case AVAHI_BROWSER_REMOVE:
1064
1278
  case AVAHI_BROWSER_ALL_FOR_NOW:
1065
1279
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
1066
1280
    if(debug){
1067
 
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
1281
      fprintf_plus(stderr, "No Mandos server found, still"
 
1282
                   " searching...\n");
1068
1283
    }
1069
1284
    break;
1070
1285
  }
1079
1294
  signal_received = sig;
1080
1295
  int old_errno = errno;
1081
1296
  /* set main loop to exit */
1082
 
  if(mc.simple_poll != NULL){
1083
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1297
  if(simple_poll != NULL){
 
1298
    avahi_simple_poll_quit(simple_poll);
1084
1299
  }
1085
1300
  errno = old_errno;
1086
1301
}
1087
1302
 
 
1303
__attribute__((nonnull, warn_unused_result))
 
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
 
1305
  int ret;
 
1306
  error_t ret_errno;
 
1307
  
 
1308
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1309
  if(s < 0){
 
1310
    ret_errno = errno;
 
1311
    perror_plus("socket");
 
1312
    errno = ret_errno;
 
1313
    return false;
 
1314
  }
 
1315
  strcpy(ifr->ifr_name, ifname);
 
1316
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
 
1317
  if(ret == -1){
 
1318
    if(debug){
 
1319
      ret_errno = errno;
 
1320
      perror_plus("ioctl SIOCGIFFLAGS");
 
1321
      errno = ret_errno;
 
1322
    }
 
1323
    return false;
 
1324
  }
 
1325
  return true;
 
1326
}
 
1327
 
 
1328
__attribute__((nonnull, warn_unused_result))
 
1329
bool good_flags(const char *ifname, const struct ifreq *ifr){
 
1330
  
 
1331
  /* Reject the loopback device */
 
1332
  if(ifr->ifr_flags & IFF_LOOPBACK){
 
1333
    if(debug){
 
1334
      fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
 
1335
                   ifname);
 
1336
    }
 
1337
    return false;
 
1338
  }
 
1339
  /* Accept point-to-point devices only if connect_to is specified */
 
1340
  if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
 
1341
    if(debug){
 
1342
      fprintf_plus(stderr, "Accepting point-to-point interface"
 
1343
                   " \"%s\"\n", ifname);
 
1344
    }
 
1345
    return true;
 
1346
  }
 
1347
  /* Otherwise, reject non-broadcast-capable devices */
 
1348
  if(not (ifr->ifr_flags & IFF_BROADCAST)){
 
1349
    if(debug){
 
1350
      fprintf_plus(stderr, "Rejecting non-broadcast interface"
 
1351
                   " \"%s\"\n", ifname);
 
1352
    }
 
1353
    return false;
 
1354
  }
 
1355
  /* Reject non-ARP interfaces (including dummy interfaces) */
 
1356
  if(ifr->ifr_flags & IFF_NOARP){
 
1357
    if(debug){
 
1358
      fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
 
1359
                   ifname);
 
1360
    }
 
1361
    return false;
 
1362
  }
 
1363
  
 
1364
  /* Accept this device */
 
1365
  if(debug){
 
1366
    fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
 
1367
  }
 
1368
  return true;
 
1369
}
 
1370
 
1088
1371
/* 
1089
1372
 * This function determines if a directory entry in /sys/class/net
1090
1373
 * corresponds to an acceptable network device.
1091
1374
 * (This function is passed to scandir(3) as a filter function.)
1092
1375
 */
 
1376
__attribute__((nonnull, warn_unused_result))
1093
1377
int good_interface(const struct dirent *if_entry){
1094
 
  ssize_t ssret;
1095
 
  char *flagname = NULL;
1096
1378
  if(if_entry->d_name[0] == '.'){
1097
1379
    return 0;
1098
1380
  }
1099
 
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1100
 
                     if_entry->d_name);
1101
 
  if(ret < 0){
1102
 
    perror_plus("asprintf");
1103
 
    return 0;
1104
 
  }
1105
 
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1106
 
  if(flags_fd == -1){
1107
 
    perror_plus("open");
1108
 
    free(flagname);
1109
 
    return 0;
1110
 
  }
1111
 
  free(flagname);
1112
 
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
1113
 
  /* read line from flags_fd */
1114
 
  ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1115
 
  char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1116
 
  flagstring[(size_t)to_read] = '\0';
1117
 
  if(flagstring == NULL){
1118
 
    perror_plus("malloc");
1119
 
    close(flags_fd);
1120
 
    return 0;
1121
 
  }
1122
 
  while(to_read > 0){
1123
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1124
 
                                             (size_t)to_read));
1125
 
    if(ssret == -1){
1126
 
      perror_plus("read");
1127
 
      free(flagstring);
1128
 
      close(flags_fd);
1129
 
      return 0;
1130
 
    }
1131
 
    to_read -= ssret;
1132
 
    if(ssret == 0){
1133
 
      break;
1134
 
    }
1135
 
  }
1136
 
  close(flags_fd);
1137
 
  intmax_t tmpmax;
1138
 
  char *tmp;
1139
 
  errno = 0;
1140
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1141
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1142
 
                                         and not (isspace(*tmp)))
1143
 
     or tmpmax != (ifreq_flags)tmpmax){
1144
 
    if(debug){
1145
 
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1146
 
              flagstring, if_entry->d_name);
1147
 
    }
1148
 
    free(flagstring);
1149
 
    return 0;
1150
 
  }
1151
 
  free(flagstring);
1152
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
1153
 
  /* Reject the loopback device */
1154
 
  if(flags & IFF_LOOPBACK){
1155
 
    if(debug){
1156
 
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1157
 
              if_entry->d_name);
1158
 
    }
1159
 
    return 0;
1160
 
  }
1161
 
  /* Accept point-to-point devices only if connect_to is specified */
1162
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1163
 
    if(debug){
1164
 
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1165
 
              if_entry->d_name);
1166
 
    }
1167
 
    return 1;
1168
 
  }
1169
 
  /* Otherwise, reject non-broadcast-capable devices */
1170
 
  if(not (flags & IFF_BROADCAST)){
1171
 
    if(debug){
1172
 
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1173
 
              if_entry->d_name);
1174
 
    }
1175
 
    return 0;
1176
 
  }
1177
 
  /* Reject non-ARP interfaces (including dummy interfaces) */
1178
 
  if(flags & IFF_NOARP){
1179
 
    if(debug){
1180
 
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1181
 
              if_entry->d_name);
1182
 
    }
1183
 
    return 0;
1184
 
  }
1185
 
  /* Accept this device */
1186
 
  if(debug){
1187
 
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
1188
 
            if_entry->d_name);
 
1381
  
 
1382
  struct ifreq ifr;
 
1383
  if(not get_flags(if_entry->d_name, &ifr)){
 
1384
    if(debug){
 
1385
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1386
                   "\"%s\"\n", if_entry->d_name);
 
1387
    }
 
1388
    return 0;
 
1389
  }
 
1390
  
 
1391
  if(not good_flags(if_entry->d_name, &ifr)){
 
1392
    return 0;
1189
1393
  }
1190
1394
  return 1;
1191
1395
}
1192
1396
 
 
1397
/* 
 
1398
 * This function determines if a network interface is up.
 
1399
 */
 
1400
__attribute__((nonnull, warn_unused_result))
 
1401
bool interface_is_up(const char *interface){
 
1402
  struct ifreq ifr;
 
1403
  if(not get_flags(interface, &ifr)){
 
1404
    if(debug){
 
1405
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1406
                   "\"%s\"\n", interface);
 
1407
    }
 
1408
    return false;
 
1409
  }
 
1410
  
 
1411
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1412
}
 
1413
 
 
1414
/* 
 
1415
 * This function determines if a network interface is running
 
1416
 */
 
1417
__attribute__((nonnull, warn_unused_result))
 
1418
bool interface_is_running(const char *interface){
 
1419
  struct ifreq ifr;
 
1420
  if(not get_flags(interface, &ifr)){
 
1421
    if(debug){
 
1422
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1423
                   "\"%s\"\n", interface);
 
1424
    }
 
1425
    return false;
 
1426
  }
 
1427
  
 
1428
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1429
}
 
1430
 
 
1431
__attribute__((nonnull, pure, warn_unused_result))
1193
1432
int notdotentries(const struct dirent *direntry){
1194
1433
  /* Skip "." and ".." */
1195
1434
  if(direntry->d_name[0] == '.'
1201
1440
  return 1;
1202
1441
}
1203
1442
 
1204
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1443
/* Is this directory entry a runnable program? */
 
1444
__attribute__((nonnull, warn_unused_result))
 
1445
int runnable_hook(const struct dirent *direntry){
 
1446
  int ret;
 
1447
  size_t sret;
 
1448
  struct stat st;
 
1449
  
 
1450
  if((direntry->d_name)[0] == '\0'){
 
1451
    /* Empty name? */
 
1452
    return 0;
 
1453
  }
 
1454
  
 
1455
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
1456
                "abcdefghijklmnopqrstuvwxyz"
 
1457
                "0123456789"
 
1458
                "_.-");
 
1459
  if((direntry->d_name)[sret] != '\0'){
 
1460
    /* Contains non-allowed characters */
 
1461
    if(debug){
 
1462
      fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
 
1463
                   direntry->d_name);
 
1464
    }
 
1465
    return 0;
 
1466
  }
 
1467
  
 
1468
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
 
1469
  if(ret == -1){
 
1470
    if(debug){
 
1471
      perror_plus("Could not stat hook");
 
1472
    }
 
1473
    return 0;
 
1474
  }
 
1475
  if(not (S_ISREG(st.st_mode))){
 
1476
    /* Not a regular file */
 
1477
    if(debug){
 
1478
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
 
1479
                   direntry->d_name);
 
1480
    }
 
1481
    return 0;
 
1482
  }
 
1483
  if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
 
1484
    /* Not executable */
 
1485
    if(debug){
 
1486
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
 
1487
                   direntry->d_name);
 
1488
    }
 
1489
    return 0;
 
1490
  }
 
1491
  if(debug){
 
1492
    fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
 
1493
                 direntry->d_name);
 
1494
  }
 
1495
  return 1;
 
1496
}
 
1497
 
 
1498
__attribute__((nonnull, warn_unused_result))
 
1499
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
1500
                            mandos_context *mc){
1205
1501
  int ret;
1206
1502
  struct timespec now;
1207
1503
  struct timespec waited_time;
1208
1504
  intmax_t block_time;
1209
1505
  
1210
1506
  while(true){
1211
 
    if(mc.current_server == NULL){
1212
 
      if (debug){
1213
 
        fprintf(stderr,
1214
 
                "Wait until first server is found. No timeout!\n");
 
1507
    if(mc->current_server == NULL){
 
1508
      if(debug){
 
1509
        fprintf_plus(stderr, "Wait until first server is found."
 
1510
                     " No timeout!\n");
1215
1511
      }
1216
1512
      ret = avahi_simple_poll_iterate(s, -1);
1217
1513
    } else {
1218
 
      if (debug){
1219
 
        fprintf(stderr, "Check current_server if we should run it,"
1220
 
                " or wait\n");
 
1514
      if(debug){
 
1515
        fprintf_plus(stderr, "Check current_server if we should run"
 
1516
                     " it, or wait\n");
1221
1517
      }
1222
1518
      /* the current time */
1223
1519
      ret = clock_gettime(CLOCK_MONOTONIC, &now);
1228
1524
      /* Calculating in ms how long time between now and server
1229
1525
         who we visted longest time ago. Now - last seen.  */
1230
1526
      waited_time.tv_sec = (now.tv_sec
1231
 
                            - mc.current_server->last_seen.tv_sec);
 
1527
                            - mc->current_server->last_seen.tv_sec);
1232
1528
      waited_time.tv_nsec = (now.tv_nsec
1233
 
                             - mc.current_server->last_seen.tv_nsec);
 
1529
                             - mc->current_server->last_seen.tv_nsec);
1234
1530
      /* total time is 10s/10,000ms.
1235
1531
         Converting to s from ms by dividing by 1,000,
1236
1532
         and ns to ms by dividing by 1,000,000. */
1238
1534
                     - ((intmax_t)waited_time.tv_sec * 1000))
1239
1535
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1240
1536
      
1241
 
      if (debug){
1242
 
        fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);
 
1537
      if(debug){
 
1538
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
 
1539
                     block_time);
1243
1540
      }
1244
1541
      
1245
1542
      if(block_time <= 0){
1246
 
        ret = start_mandos_communication(mc.current_server->ip,
1247
 
                                         mc.current_server->port,
1248
 
                                         mc.current_server->if_index,
1249
 
                                         mc.current_server->af);
 
1543
        ret = start_mandos_communication(mc->current_server->ip,
 
1544
                                         mc->current_server->port,
 
1545
                                         mc->current_server->if_index,
 
1546
                                         mc->current_server->af, mc);
1250
1547
        if(ret == 0){
1251
 
          avahi_simple_poll_quit(mc.simple_poll);
 
1548
          avahi_simple_poll_quit(s);
1252
1549
          return 0;
1253
1550
        }
1254
1551
        ret = clock_gettime(CLOCK_MONOTONIC,
1255
 
                            &mc.current_server->last_seen);
 
1552
                            &mc->current_server->last_seen);
1256
1553
        if(ret == -1){
1257
1554
          perror_plus("clock_gettime");
1258
1555
          return -1;
1259
1556
        }
1260
 
        mc.current_server = mc.current_server->next;
 
1557
        mc->current_server = mc->current_server->next;
1261
1558
        block_time = 0;         /* Call avahi to find new Mandos
1262
1559
                                   servers, but don't block */
1263
1560
      }
1265
1562
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1266
1563
    }
1267
1564
    if(ret != 0){
1268
 
      if (ret > 0 or errno != EINTR) {
 
1565
      if(ret > 0 or errno != EINTR){
1269
1566
        return (ret != 1) ? ret : 0;
1270
1567
      }
1271
1568
    }
1272
1569
  }
1273
1570
}
1274
1571
 
 
1572
/* Set effective uid to 0, return errno */
 
1573
__attribute__((warn_unused_result))
 
1574
error_t raise_privileges(void){
 
1575
  error_t old_errno = errno;
 
1576
  error_t ret_errno = 0;
 
1577
  if(seteuid(0) == -1){
 
1578
    ret_errno = errno;
 
1579
  }
 
1580
  errno = old_errno;
 
1581
  return ret_errno;
 
1582
}
 
1583
 
 
1584
/* Set effective and real user ID to 0.  Return errno. */
 
1585
__attribute__((warn_unused_result))
 
1586
error_t raise_privileges_permanently(void){
 
1587
  error_t old_errno = errno;
 
1588
  error_t ret_errno = raise_privileges();
 
1589
  if(ret_errno != 0){
 
1590
    errno = old_errno;
 
1591
    return ret_errno;
 
1592
  }
 
1593
  if(setuid(0) == -1){
 
1594
    ret_errno = errno;
 
1595
  }
 
1596
  errno = old_errno;
 
1597
  return ret_errno;
 
1598
}
 
1599
 
 
1600
/* Set effective user ID to unprivileged saved user ID */
 
1601
__attribute__((warn_unused_result))
 
1602
error_t lower_privileges(void){
 
1603
  error_t old_errno = errno;
 
1604
  error_t ret_errno = 0;
 
1605
  if(seteuid(uid) == -1){
 
1606
    ret_errno = errno;
 
1607
  }
 
1608
  errno = old_errno;
 
1609
  return ret_errno;
 
1610
}
 
1611
 
 
1612
/* Lower privileges permanently */
 
1613
__attribute__((warn_unused_result))
 
1614
error_t lower_privileges_permanently(void){
 
1615
  error_t old_errno = errno;
 
1616
  error_t ret_errno = 0;
 
1617
  if(setuid(uid) == -1){
 
1618
    ret_errno = errno;
 
1619
  }
 
1620
  errno = old_errno;
 
1621
  return ret_errno;
 
1622
}
 
1623
 
 
1624
__attribute__((nonnull))
 
1625
void run_network_hooks(const char *mode, const char *interface,
 
1626
                       const float delay){
 
1627
  struct dirent **direntries = NULL;
 
1628
  if(hookdir_fd == -1){
 
1629
    hookdir_fd = open(hookdir, O_RDONLY);
 
1630
    if(hookdir_fd == -1){
 
1631
      if(errno == ENOENT){
 
1632
        if(debug){
 
1633
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1634
                       " found\n", hookdir);
 
1635
        }
 
1636
      } else {
 
1637
        perror_plus("open");
 
1638
      }
 
1639
      return;
 
1640
    }
 
1641
  }
 
1642
#ifdef __GLIBC__
 
1643
#if __GLIBC_PREREQ(2, 15)
 
1644
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
1645
                           runnable_hook, alphasort);
 
1646
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1647
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1648
                         alphasort);
 
1649
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1650
#else   /* not __GLIBC__ */
 
1651
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1652
                         alphasort);
 
1653
#endif  /* not __GLIBC__ */
 
1654
  if(numhooks == -1){
 
1655
    perror_plus("scandir");
 
1656
    return;
 
1657
  }
 
1658
  struct dirent *direntry;
 
1659
  int ret;
 
1660
  int devnull = open("/dev/null", O_RDONLY);
 
1661
  for(int i = 0; i < numhooks; i++){
 
1662
    direntry = direntries[i];
 
1663
    if(debug){
 
1664
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1665
                   direntry->d_name);
 
1666
    }
 
1667
    pid_t hook_pid = fork();
 
1668
    if(hook_pid == 0){
 
1669
      /* Child */
 
1670
      /* Raise privileges */
 
1671
      errno = raise_privileges_permanently();
 
1672
      if(errno != 0){
 
1673
        perror_plus("Failed to raise privileges");
 
1674
        _exit(EX_NOPERM);
 
1675
      }
 
1676
      /* Set group */
 
1677
      errno = 0;
 
1678
      ret = setgid(0);
 
1679
      if(ret == -1){
 
1680
        perror_plus("setgid");
 
1681
        _exit(EX_NOPERM);
 
1682
      }
 
1683
      /* Reset supplementary groups */
 
1684
      errno = 0;
 
1685
      ret = setgroups(0, NULL);
 
1686
      if(ret == -1){
 
1687
        perror_plus("setgroups");
 
1688
        _exit(EX_NOPERM);
 
1689
      }
 
1690
      ret = dup2(devnull, STDIN_FILENO);
 
1691
      if(ret == -1){
 
1692
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
1693
        _exit(EX_OSERR);
 
1694
      }
 
1695
      ret = close(devnull);
 
1696
      if(ret == -1){
 
1697
        perror_plus("close");
 
1698
        _exit(EX_OSERR);
 
1699
      }
 
1700
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1701
      if(ret == -1){
 
1702
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1703
        _exit(EX_OSERR);
 
1704
      }
 
1705
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1706
      if(ret == -1){
 
1707
        perror_plus("setenv");
 
1708
        _exit(EX_OSERR);
 
1709
      }
 
1710
      ret = setenv("DEVICE", interface, 1);
 
1711
      if(ret == -1){
 
1712
        perror_plus("setenv");
 
1713
        _exit(EX_OSERR);
 
1714
      }
 
1715
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1716
      if(ret == -1){
 
1717
        perror_plus("setenv");
 
1718
        _exit(EX_OSERR);
 
1719
      }
 
1720
      ret = setenv("MODE", mode, 1);
 
1721
      if(ret == -1){
 
1722
        perror_plus("setenv");
 
1723
        _exit(EX_OSERR);
 
1724
      }
 
1725
      char *delaystring;
 
1726
      ret = asprintf(&delaystring, "%f", (double)delay);
 
1727
      if(ret == -1){
 
1728
        perror_plus("asprintf");
 
1729
        _exit(EX_OSERR);
 
1730
      }
 
1731
      ret = setenv("DELAY", delaystring, 1);
 
1732
      if(ret == -1){
 
1733
        free(delaystring);
 
1734
        perror_plus("setenv");
 
1735
        _exit(EX_OSERR);
 
1736
      }
 
1737
      free(delaystring);
 
1738
      if(connect_to != NULL){
 
1739
        ret = setenv("CONNECT", connect_to, 1);
 
1740
        if(ret == -1){
 
1741
          perror_plus("setenv");
 
1742
          _exit(EX_OSERR);
 
1743
        }
 
1744
      }
 
1745
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
 
1746
      if(hook_fd == -1){
 
1747
        perror_plus("openat");
 
1748
        _exit(EXIT_FAILURE);
 
1749
      }
 
1750
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
1751
        perror_plus("close");
 
1752
        _exit(EXIT_FAILURE);
 
1753
      }
 
1754
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
1755
                 environ) == -1){
 
1756
        perror_plus("fexecve");
 
1757
        _exit(EXIT_FAILURE);
 
1758
      }
 
1759
    } else {
 
1760
      if(hook_pid == -1){
 
1761
        perror_plus("fork");
 
1762
        free(direntry);
 
1763
        continue;
 
1764
      }
 
1765
      int status;
 
1766
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
1767
        perror_plus("waitpid");
 
1768
        free(direntry);
 
1769
        continue;
 
1770
      }
 
1771
      if(WIFEXITED(status)){
 
1772
        if(WEXITSTATUS(status) != 0){
 
1773
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
1774
                       " with status %d\n", direntry->d_name,
 
1775
                       WEXITSTATUS(status));
 
1776
          free(direntry);
 
1777
          continue;
 
1778
        }
 
1779
      } else if(WIFSIGNALED(status)){
 
1780
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
1781
                     " signal %d\n", direntry->d_name,
 
1782
                     WTERMSIG(status));
 
1783
        free(direntry);
 
1784
        continue;
 
1785
      } else {
 
1786
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
1787
                     " crashed\n", direntry->d_name);
 
1788
        free(direntry);
 
1789
        continue;
 
1790
      }
 
1791
    }
 
1792
    if(debug){
 
1793
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
1794
                   direntry->d_name);
 
1795
    }
 
1796
    free(direntry);
 
1797
  }
 
1798
  free(direntries);
 
1799
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
1800
    perror_plus("close");
 
1801
  } else {
 
1802
    hookdir_fd = -1;
 
1803
  }
 
1804
  close(devnull);
 
1805
}
 
1806
 
 
1807
__attribute__((nonnull, warn_unused_result))
 
1808
error_t bring_up_interface(const char *const interface,
 
1809
                           const float delay){
 
1810
  error_t old_errno = errno;
 
1811
  int ret;
 
1812
  struct ifreq network;
 
1813
  unsigned int if_index = if_nametoindex(interface);
 
1814
  if(if_index == 0){
 
1815
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1816
    errno = old_errno;
 
1817
    return ENXIO;
 
1818
  }
 
1819
  
 
1820
  if(quit_now){
 
1821
    errno = old_errno;
 
1822
    return EINTR;
 
1823
  }
 
1824
  
 
1825
  if(not interface_is_up(interface)){
 
1826
    error_t ret_errno = 0, ioctl_errno = 0;
 
1827
    if(not get_flags(interface, &network)){
 
1828
      ret_errno = errno;
 
1829
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1830
                   "\"%s\"\n", interface);
 
1831
      errno = old_errno;
 
1832
      return ret_errno;
 
1833
    }
 
1834
    network.ifr_flags |= IFF_UP; /* set flag */
 
1835
    
 
1836
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1837
    if(sd == -1){
 
1838
      ret_errno = errno;
 
1839
      perror_plus("socket");
 
1840
      errno = old_errno;
 
1841
      return ret_errno;
 
1842
    }
 
1843
    
 
1844
    if(quit_now){
 
1845
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1846
      if(ret == -1){
 
1847
        perror_plus("close");
 
1848
      }
 
1849
      errno = old_errno;
 
1850
      return EINTR;
 
1851
    }
 
1852
    
 
1853
    if(debug){
 
1854
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
1855
                   interface);
 
1856
    }
 
1857
    
 
1858
    /* Raise privileges */
 
1859
    ret_errno = raise_privileges();
 
1860
    if(ret_errno != 0){
 
1861
      errno = ret_errno;
 
1862
      perror_plus("Failed to raise privileges");
 
1863
    }
 
1864
    
 
1865
#ifdef __linux__
 
1866
    int ret_linux;
 
1867
    bool restore_loglevel = false;
 
1868
    if(ret_errno == 0){
 
1869
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1870
         messages about the network interface to mess up the prompt */
 
1871
      ret_linux = klogctl(8, NULL, 5);
 
1872
      if(ret_linux == -1){
 
1873
        perror_plus("klogctl");
 
1874
      } else {
 
1875
        restore_loglevel = true;
 
1876
      }
 
1877
    }
 
1878
#endif  /* __linux__ */
 
1879
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1880
    ioctl_errno = errno;
 
1881
#ifdef __linux__
 
1882
    if(restore_loglevel){
 
1883
      ret_linux = klogctl(7, NULL, 0);
 
1884
      if(ret_linux == -1){
 
1885
        perror_plus("klogctl");
 
1886
      }
 
1887
    }
 
1888
#endif  /* __linux__ */
 
1889
    
 
1890
    /* If raise_privileges() succeeded above */
 
1891
    if(ret_errno == 0){
 
1892
      /* Lower privileges */
 
1893
      ret_errno = lower_privileges();
 
1894
      if(ret_errno != 0){
 
1895
        errno = ret_errno;
 
1896
        perror_plus("Failed to lower privileges");
 
1897
      }
 
1898
    }
 
1899
    
 
1900
    /* Close the socket */
 
1901
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1902
    if(ret == -1){
 
1903
      perror_plus("close");
 
1904
    }
 
1905
    
 
1906
    if(ret_setflags == -1){
 
1907
      errno = ioctl_errno;
 
1908
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
1909
      errno = old_errno;
 
1910
      return ioctl_errno;
 
1911
    }
 
1912
  } else if(debug){
 
1913
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
1914
                 interface);
 
1915
  }
 
1916
  
 
1917
  /* Sleep checking until interface is running.
 
1918
     Check every 0.25s, up to total time of delay */
 
1919
  for(int i=0; i < delay * 4; i++){
 
1920
    if(interface_is_running(interface)){
 
1921
      break;
 
1922
    }
 
1923
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1924
    ret = nanosleep(&sleeptime, NULL);
 
1925
    if(ret == -1 and errno != EINTR){
 
1926
      perror_plus("nanosleep");
 
1927
    }
 
1928
  }
 
1929
  
 
1930
  errno = old_errno;
 
1931
  return 0;
 
1932
}
 
1933
 
 
1934
__attribute__((nonnull, warn_unused_result))
 
1935
error_t take_down_interface(const char *const interface){
 
1936
  error_t old_errno = errno;
 
1937
  struct ifreq network;
 
1938
  unsigned int if_index = if_nametoindex(interface);
 
1939
  if(if_index == 0){
 
1940
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1941
    errno = old_errno;
 
1942
    return ENXIO;
 
1943
  }
 
1944
  if(interface_is_up(interface)){
 
1945
    error_t ret_errno = 0, ioctl_errno = 0;
 
1946
    if(not get_flags(interface, &network) and debug){
 
1947
      ret_errno = errno;
 
1948
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1949
                   "\"%s\"\n", interface);
 
1950
      errno = old_errno;
 
1951
      return ret_errno;
 
1952
    }
 
1953
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1954
    
 
1955
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1956
    if(sd == -1){
 
1957
      ret_errno = errno;
 
1958
      perror_plus("socket");
 
1959
      errno = old_errno;
 
1960
      return ret_errno;
 
1961
    }
 
1962
    
 
1963
    if(debug){
 
1964
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
1965
                   interface);
 
1966
    }
 
1967
    
 
1968
    /* Raise privileges */
 
1969
    ret_errno = raise_privileges();
 
1970
    if(ret_errno != 0){
 
1971
      errno = ret_errno;
 
1972
      perror_plus("Failed to raise privileges");
 
1973
    }
 
1974
    
 
1975
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1976
    ioctl_errno = errno;
 
1977
    
 
1978
    /* If raise_privileges() succeeded above */
 
1979
    if(ret_errno == 0){
 
1980
      /* Lower privileges */
 
1981
      ret_errno = lower_privileges();
 
1982
      if(ret_errno != 0){
 
1983
        errno = ret_errno;
 
1984
        perror_plus("Failed to lower privileges");
 
1985
      }
 
1986
    }
 
1987
    
 
1988
    /* Close the socket */
 
1989
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1990
    if(ret == -1){
 
1991
      perror_plus("close");
 
1992
    }
 
1993
    
 
1994
    if(ret_setflags == -1){
 
1995
      errno = ioctl_errno;
 
1996
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1997
      errno = old_errno;
 
1998
      return ioctl_errno;
 
1999
    }
 
2000
  } else if(debug){
 
2001
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
2002
                 interface);
 
2003
  }
 
2004
  
 
2005
  errno = old_errno;
 
2006
  return 0;
 
2007
}
 
2008
 
1275
2009
int main(int argc, char *argv[]){
 
2010
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2011
                        .priority = "SECURE256:!CTYPE-X.509:"
 
2012
                        "+CTYPE-OPENPGP:!RSA", .current_server = NULL,
 
2013
                        .interfaces = NULL, .interfaces_size = 0 };
1276
2014
  AvahiSServiceBrowser *sb = NULL;
1277
 
  int error;
 
2015
  error_t ret_errno;
1278
2016
  int ret;
1279
2017
  intmax_t tmpmax;
1280
2018
  char *tmp;
1281
2019
  int exitcode = EXIT_SUCCESS;
1282
 
  const char *interface = "";
1283
 
  struct ifreq network;
1284
 
  int sd = -1;
1285
 
  bool take_down_interface = false;
1286
 
  uid_t uid;
1287
 
  gid_t gid;
1288
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1289
 
  bool tempdir_created = false;
 
2020
  char *interfaces_to_take_down = NULL;
 
2021
  size_t interfaces_to_take_down_size = 0;
 
2022
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2023
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2024
  char *tempdir = NULL;
1290
2025
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1291
2026
  const char *seckey = PATHDIR "/" SECKEY;
1292
2027
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2028
  char *interfaces_hooks = NULL;
1293
2029
  
1294
2030
  bool gnutls_initialized = false;
1295
2031
  bool gpgme_initialized = false;
1357
2093
        .group = 2 },
1358
2094
      { .name = "retry", .key = 132,
1359
2095
        .arg = "SECONDS",
1360
 
        .doc = "Retry interval used when denied by the mandos server",
 
2096
        .doc = "Retry interval used when denied by the Mandos server",
 
2097
        .group = 2 },
 
2098
      { .name = "network-hook-dir", .key = 133,
 
2099
        .arg = "DIR",
 
2100
        .doc = "Directory where network hooks are located",
1361
2101
        .group = 2 },
1362
2102
      /*
1363
2103
       * These reproduce what we would get without ARGP_NO_HELP
1382
2122
        connect_to = arg;
1383
2123
        break;
1384
2124
      case 'i':                 /* --interface */
1385
 
        interface = arg;
 
2125
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2126
                                 arg, (int)',');
 
2127
        if(ret_errno != 0){
 
2128
          argp_error(state, "%s", strerror(ret_errno));
 
2129
        }
1386
2130
        break;
1387
2131
      case 's':                 /* --seckey */
1388
2132
        seckey = arg;
1417
2161
          argp_error(state, "Bad retry interval");
1418
2162
        }
1419
2163
        break;
 
2164
      case 133:                 /* --network-hook-dir */
 
2165
        hookdir = arg;
 
2166
        break;
1420
2167
        /*
1421
2168
         * These reproduce what we would get without ARGP_NO_HELP
1422
2169
         */
1428
2175
        argp_state_help(state, state->out_stream,
1429
2176
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1430
2177
      case 'V':                 /* --version */
1431
 
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
2178
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1432
2179
        exit(argp_err_exit_status);
1433
2180
        break;
1434
2181
      default:
1461
2208
  {
1462
2209
    /* Work around Debian bug #633582:
1463
2210
       <http://bugs.debian.org/633582> */
1464
 
    struct stat st;
1465
 
    
1466
 
    /* Re-raise priviliges */
1467
 
    errno = 0;
1468
 
    ret = seteuid(0);
1469
 
    if(ret == -1){
1470
 
      perror_plus("seteuid");
1471
 
    }
1472
 
    
1473
 
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1474
 
      int seckey_fd = open(seckey, O_RDONLY);
1475
 
      if(seckey_fd == -1){
1476
 
        perror_plus("open");
1477
 
      } else {
1478
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1479
 
        if(ret == -1){
1480
 
          perror_plus("fstat");
1481
 
        } else {
1482
 
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1483
 
            ret = fchown(seckey_fd, uid, gid);
1484
 
            if(ret == -1){
1485
 
              perror_plus("fchown");
1486
 
            }
1487
 
          }
1488
 
        }
1489
 
        TEMP_FAILURE_RETRY(close(seckey_fd));
1490
 
      }
1491
 
    }
1492
 
    
1493
 
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1494
 
      int pubkey_fd = open(pubkey, O_RDONLY);
1495
 
      if(pubkey_fd == -1){
1496
 
        perror_plus("open");
1497
 
      } else {
1498
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1499
 
        if(ret == -1){
1500
 
          perror_plus("fstat");
1501
 
        } else {
1502
 
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1503
 
            ret = fchown(pubkey_fd, uid, gid);
1504
 
            if(ret == -1){
1505
 
              perror_plus("fchown");
1506
 
            }
1507
 
          }
1508
 
        }
1509
 
        TEMP_FAILURE_RETRY(close(pubkey_fd));
1510
 
      }
1511
 
    }
1512
 
    
1513
 
    /* Lower privileges */
1514
 
    errno = 0;
1515
 
    ret = seteuid(uid);
1516
 
    if(ret == -1){
1517
 
      perror_plus("seteuid");
1518
 
    }
 
2211
    
 
2212
    /* Re-raise privileges */
 
2213
    ret_errno = raise_privileges();
 
2214
    if(ret_errno != 0){
 
2215
      errno = ret_errno;
 
2216
      perror_plus("Failed to raise privileges");
 
2217
    } else {
 
2218
      struct stat st;
 
2219
      
 
2220
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
2221
        int seckey_fd = open(seckey, O_RDONLY);
 
2222
        if(seckey_fd == -1){
 
2223
          perror_plus("open");
 
2224
        } else {
 
2225
          ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
2226
          if(ret == -1){
 
2227
            perror_plus("fstat");
 
2228
          } else {
 
2229
            if(S_ISREG(st.st_mode)
 
2230
               and st.st_uid == 0 and st.st_gid == 0){
 
2231
              ret = fchown(seckey_fd, uid, gid);
 
2232
              if(ret == -1){
 
2233
                perror_plus("fchown");
 
2234
              }
 
2235
            }
 
2236
          }
 
2237
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2238
        }
 
2239
      }
 
2240
    
 
2241
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
2242
        int pubkey_fd = open(pubkey, O_RDONLY);
 
2243
        if(pubkey_fd == -1){
 
2244
          perror_plus("open");
 
2245
        } else {
 
2246
          ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
2247
          if(ret == -1){
 
2248
            perror_plus("fstat");
 
2249
          } else {
 
2250
            if(S_ISREG(st.st_mode)
 
2251
               and st.st_uid == 0 and st.st_gid == 0){
 
2252
              ret = fchown(pubkey_fd, uid, gid);
 
2253
              if(ret == -1){
 
2254
                perror_plus("fchown");
 
2255
              }
 
2256
            }
 
2257
          }
 
2258
          TEMP_FAILURE_RETRY(close(pubkey_fd));
 
2259
        }
 
2260
      }
 
2261
    
 
2262
      /* Lower privileges */
 
2263
      ret_errno = lower_privileges();
 
2264
      if(ret_errno != 0){
 
2265
        errno = ret_errno;
 
2266
        perror_plus("Failed to lower privileges");
 
2267
      }
 
2268
    }
 
2269
  }
 
2270
  
 
2271
  /* Remove invalid interface names (except "none") */
 
2272
  {
 
2273
    char *interface = NULL;
 
2274
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2275
                                 interface))){
 
2276
      if(strcmp(interface, "none") != 0
 
2277
         and if_nametoindex(interface) == 0){
 
2278
        if(interface[0] != '\0'){
 
2279
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2280
                       " \"%s\"\n", interface);
 
2281
        }
 
2282
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
 
2283
        interface = NULL;
 
2284
      }
 
2285
    }
 
2286
  }
 
2287
  
 
2288
  /* Run network hooks */
 
2289
  {
 
2290
    if(mc.interfaces != NULL){
 
2291
      interfaces_hooks = malloc(mc.interfaces_size);
 
2292
      if(interfaces_hooks == NULL){
 
2293
        perror_plus("malloc");
 
2294
        goto end;
 
2295
      }
 
2296
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2297
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2298
    }
 
2299
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2300
                      interfaces_hooks : "", delay);
1519
2301
  }
1520
2302
  
1521
2303
  if(not debug){
1522
2304
    avahi_set_log_function(empty_log);
1523
2305
  }
1524
 
 
1525
 
  if(interface[0] == '\0'){
1526
 
    struct dirent **direntries;
1527
 
    ret = scandir(sys_class_net, &direntries, good_interface,
1528
 
                  alphasort);
1529
 
    if(ret >= 1){
1530
 
      /* Pick the first good interface */
1531
 
      interface = strdup(direntries[0]->d_name);
1532
 
      if(debug){
1533
 
        fprintf(stderr, "Using interface \"%s\"\n", interface);
1534
 
      }
1535
 
      if(interface == NULL){
1536
 
        perror_plus("malloc");
1537
 
        free(direntries);
1538
 
        exitcode = EXIT_FAILURE;
1539
 
        goto end;
1540
 
      }
1541
 
      free(direntries);
1542
 
    } else {
1543
 
      free(direntries);
1544
 
      fprintf(stderr, "Could not find a network interface\n");
1545
 
      exitcode = EXIT_FAILURE;
1546
 
      goto end;
1547
 
    }
1548
 
  }
1549
2306
  
1550
2307
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1551
2308
     from the signal handler */
1552
2309
  /* Initialize the pseudo-RNG for Avahi */
1553
2310
  srand((unsigned int) time(NULL));
1554
 
  mc.simple_poll = avahi_simple_poll_new();
1555
 
  if(mc.simple_poll == NULL){
1556
 
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
2311
  simple_poll = avahi_simple_poll_new();
 
2312
  if(simple_poll == NULL){
 
2313
    fprintf_plus(stderr,
 
2314
                 "Avahi: Failed to create simple poll object.\n");
1557
2315
    exitcode = EX_UNAVAILABLE;
1558
2316
    goto end;
1559
2317
  }
1621
2379
    }
1622
2380
  }
1623
2381
  
1624
 
  /* If the interface is down, bring it up */
1625
 
  if(strcmp(interface, "none") != 0){
1626
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1627
 
    if(if_index == 0){
1628
 
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
1629
 
      exitcode = EX_UNAVAILABLE;
1630
 
      goto end;
1631
 
    }
1632
 
    
1633
 
    if(quit_now){
1634
 
      goto end;
1635
 
    }
1636
 
    
1637
 
    /* Re-raise priviliges */
1638
 
    errno = 0;
1639
 
    ret = seteuid(0);
1640
 
    if(ret == -1){
1641
 
      perror_plus("seteuid");
1642
 
    }
1643
 
    
1644
 
#ifdef __linux__
1645
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1646
 
       messages about the network interface to mess up the prompt */
1647
 
    ret = klogctl(8, NULL, 5);
1648
 
    bool restore_loglevel = true;
1649
 
    if(ret == -1){
1650
 
      restore_loglevel = false;
1651
 
      perror_plus("klogctl");
1652
 
    }
1653
 
#endif  /* __linux__ */
1654
 
    
1655
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1656
 
    if(sd < 0){
1657
 
      perror_plus("socket");
1658
 
      exitcode = EX_OSERR;
1659
 
#ifdef __linux__
1660
 
      if(restore_loglevel){
1661
 
        ret = klogctl(7, NULL, 0);
1662
 
        if(ret == -1){
1663
 
          perror_plus("klogctl");
1664
 
        }
1665
 
      }
1666
 
#endif  /* __linux__ */
1667
 
      /* Lower privileges */
1668
 
      errno = 0;
1669
 
      ret = seteuid(uid);
1670
 
      if(ret == -1){
1671
 
        perror_plus("seteuid");
1672
 
      }
1673
 
      goto end;
1674
 
    }
1675
 
    strcpy(network.ifr_name, interface);
1676
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1677
 
    if(ret == -1){
1678
 
      perror_plus("ioctl SIOCGIFFLAGS");
1679
 
#ifdef __linux__
1680
 
      if(restore_loglevel){
1681
 
        ret = klogctl(7, NULL, 0);
1682
 
        if(ret == -1){
1683
 
          perror_plus("klogctl");
1684
 
        }
1685
 
      }
1686
 
#endif  /* __linux__ */
1687
 
      exitcode = EX_OSERR;
1688
 
      /* Lower privileges */
1689
 
      errno = 0;
1690
 
      ret = seteuid(uid);
1691
 
      if(ret == -1){
1692
 
        perror_plus("seteuid");
1693
 
      }
1694
 
      goto end;
1695
 
    }
1696
 
    if((network.ifr_flags & IFF_UP) == 0){
1697
 
      network.ifr_flags |= IFF_UP;
1698
 
      take_down_interface = true;
1699
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1700
 
      if(ret == -1){
1701
 
        take_down_interface = false;
1702
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1703
 
        exitcode = EX_OSERR;
1704
 
#ifdef __linux__
1705
 
        if(restore_loglevel){
1706
 
          ret = klogctl(7, NULL, 0);
1707
 
          if(ret == -1){
1708
 
            perror_plus("klogctl");
 
2382
  /* If no interfaces were specified, make a list */
 
2383
  if(mc.interfaces == NULL){
 
2384
    struct dirent **direntries = NULL;
 
2385
    /* Look for any good interfaces */
 
2386
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2387
                  alphasort);
 
2388
    if(ret >= 1){
 
2389
      /* Add all found interfaces to interfaces list */
 
2390
      for(int i = 0; i < ret; ++i){
 
2391
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2392
                             direntries[i]->d_name);
 
2393
        if(ret_errno != 0){
 
2394
          errno = ret_errno;
 
2395
          perror_plus("argz_add");
 
2396
          free(direntries[i]);
 
2397
          continue;
 
2398
        }
 
2399
        if(debug){
 
2400
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2401
                       direntries[i]->d_name);
 
2402
        }
 
2403
        free(direntries[i]);
 
2404
      }
 
2405
      free(direntries);
 
2406
    } else {
 
2407
      if(ret == 0){
 
2408
        free(direntries);
 
2409
      }
 
2410
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2411
      exitcode = EXIT_FAILURE;
 
2412
      goto end;
 
2413
    }
 
2414
  }
 
2415
  
 
2416
  /* Bring up interfaces which are down, and remove any "none"s */
 
2417
  {
 
2418
    char *interface = NULL;
 
2419
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2420
                                 interface))){
 
2421
      /* If interface name is "none", stop bringing up interfaces.
 
2422
         Also remove all instances of "none" from the list */
 
2423
      if(strcmp(interface, "none") == 0){
 
2424
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2425
                    interface);
 
2426
        interface = NULL;
 
2427
        while((interface = argz_next(mc.interfaces,
 
2428
                                     mc.interfaces_size, interface))){
 
2429
          if(strcmp(interface, "none") == 0){
 
2430
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2431
                        interface);
 
2432
            interface = NULL;
1709
2433
          }
1710
2434
        }
1711
 
#endif  /* __linux__ */
1712
 
        /* Lower privileges */
1713
 
        errno = 0;
1714
 
        ret = seteuid(uid);
1715
 
        if(ret == -1){
1716
 
          perror_plus("seteuid");
1717
 
        }
1718
 
        goto end;
1719
 
      }
1720
 
    }
1721
 
    /* Sleep checking until interface is running.
1722
 
       Check every 0.25s, up to total time of delay */
1723
 
    for(int i=0; i < delay * 4; i++){
1724
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1725
 
      if(ret == -1){
1726
 
        perror_plus("ioctl SIOCGIFFLAGS");
1727
 
      } else if(network.ifr_flags & IFF_RUNNING){
1728
2435
        break;
1729
2436
      }
1730
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1731
 
      ret = nanosleep(&sleeptime, NULL);
1732
 
      if(ret == -1 and errno != EINTR){
1733
 
        perror_plus("nanosleep");
1734
 
      }
1735
 
    }
1736
 
    if(not take_down_interface){
1737
 
      /* We won't need the socket anymore */
1738
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1739
 
      if(ret == -1){
1740
 
        perror_plus("close");
1741
 
      }
1742
 
    }
1743
 
#ifdef __linux__
1744
 
    if(restore_loglevel){
1745
 
      /* Restores kernel loglevel to default */
1746
 
      ret = klogctl(7, NULL, 0);
1747
 
      if(ret == -1){
1748
 
        perror_plus("klogctl");
1749
 
      }
1750
 
    }
1751
 
#endif  /* __linux__ */
1752
 
    /* Lower privileges */
1753
 
    errno = 0;
1754
 
    if(take_down_interface){
1755
 
      /* Lower privileges */
1756
 
      ret = seteuid(uid);
1757
 
      if(ret == -1){
1758
 
        perror_plus("seteuid");
1759
 
      }
1760
 
    } else {
1761
 
      /* Lower privileges permanently */
1762
 
      ret = setuid(uid);
1763
 
      if(ret == -1){
1764
 
        perror_plus("setuid");
1765
 
      }
1766
 
    }
 
2437
      bool interface_was_up = interface_is_up(interface);
 
2438
      errno = bring_up_interface(interface, delay);
 
2439
      if(not interface_was_up){
 
2440
        if(errno != 0){
 
2441
          perror_plus("Failed to bring up interface");
 
2442
        } else {
 
2443
          errno = argz_add(&interfaces_to_take_down,
 
2444
                           &interfaces_to_take_down_size,
 
2445
                           interface);
 
2446
          if(errno != 0){
 
2447
            perror_plus("argz_add");
 
2448
          }
 
2449
        }
 
2450
      }
 
2451
    }
 
2452
    if(debug and (interfaces_to_take_down == NULL)){
 
2453
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2454
    }
 
2455
  }
 
2456
  
 
2457
  /* If we only got one interface, explicitly use only that one */
 
2458
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2459
    if(debug){
 
2460
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2461
                   mc.interfaces);
 
2462
    }
 
2463
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
1767
2464
  }
1768
2465
  
1769
2466
  if(quit_now){
1770
2467
    goto end;
1771
2468
  }
1772
2469
  
1773
 
  ret = init_gnutls_global(pubkey, seckey);
 
2470
  ret = init_gnutls_global(pubkey, seckey, &mc);
1774
2471
  if(ret == -1){
1775
 
    fprintf(stderr, "init_gnutls_global failed\n");
 
2472
    fprintf_plus(stderr, "init_gnutls_global failed\n");
1776
2473
    exitcode = EX_UNAVAILABLE;
1777
2474
    goto end;
1778
2475
  } else {
1783
2480
    goto end;
1784
2481
  }
1785
2482
  
1786
 
  if(mkdtemp(tempdir) == NULL){
 
2483
  /* Try /run/tmp before /tmp */
 
2484
  tempdir = mkdtemp(run_tempdir);
 
2485
  if(tempdir == NULL and errno == ENOENT){
 
2486
      if(debug){
 
2487
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
2488
                     run_tempdir, old_tempdir);
 
2489
      }
 
2490
      tempdir = mkdtemp(old_tempdir);
 
2491
  }
 
2492
  if(tempdir == NULL){
1787
2493
    perror_plus("mkdtemp");
1788
2494
    goto end;
1789
2495
  }
1790
 
  tempdir_created = true;
1791
2496
  
1792
2497
  if(quit_now){
1793
2498
    goto end;
1794
2499
  }
1795
2500
  
1796
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
1797
 
    fprintf(stderr, "init_gpgme failed\n");
 
2501
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
 
2502
    fprintf_plus(stderr, "init_gpgme failed\n");
1798
2503
    exitcode = EX_UNAVAILABLE;
1799
2504
    goto end;
1800
2505
  } else {
1809
2514
    /* Connect directly, do not use Zeroconf */
1810
2515
    /* (Mainly meant for debugging) */
1811
2516
    char *address = strrchr(connect_to, ':');
 
2517
    
1812
2518
    if(address == NULL){
1813
 
      fprintf(stderr, "No colon in address\n");
 
2519
      fprintf_plus(stderr, "No colon in address\n");
1814
2520
      exitcode = EX_USAGE;
1815
2521
      goto end;
1816
2522
    }
1819
2525
      goto end;
1820
2526
    }
1821
2527
    
1822
 
    uint16_t port;
 
2528
    in_port_t port;
1823
2529
    errno = 0;
1824
2530
    tmpmax = strtoimax(address+1, &tmp, 10);
1825
2531
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
1826
 
       or tmpmax != (uint16_t)tmpmax){
1827
 
      fprintf(stderr, "Bad port number\n");
 
2532
       or tmpmax != (in_port_t)tmpmax){
 
2533
      fprintf_plus(stderr, "Bad port number\n");
1828
2534
      exitcode = EX_USAGE;
1829
2535
      goto end;
1830
2536
    }
1831
 
  
 
2537
    
1832
2538
    if(quit_now){
1833
2539
      goto end;
1834
2540
    }
1835
2541
    
1836
 
    port = (uint16_t)tmpmax;
 
2542
    port = (in_port_t)tmpmax;
1837
2543
    *address = '\0';
1838
2544
    /* Colon in address indicates IPv6 */
1839
2545
    int af;
1855
2561
    }
1856
2562
    
1857
2563
    while(not quit_now){
1858
 
      ret = start_mandos_communication(address, port, if_index, af);
 
2564
      ret = start_mandos_communication(address, port, if_index, af,
 
2565
                                       &mc);
1859
2566
      if(quit_now or ret == 0){
1860
2567
        break;
1861
2568
      }
1862
2569
      if(debug){
1863
 
        fprintf(stderr, "Retrying in %d seconds\n",
1864
 
                (int)retry_interval);
 
2570
        fprintf_plus(stderr, "Retrying in %d seconds\n",
 
2571
                     (int)retry_interval);
1865
2572
      }
1866
 
      sleep((int)retry_interval);
 
2573
      sleep((unsigned int)retry_interval);
1867
2574
    }
1868
2575
    
1869
 
    if (not quit_now){
 
2576
    if(not quit_now){
1870
2577
      exitcode = EXIT_SUCCESS;
1871
2578
    }
1872
 
 
 
2579
    
1873
2580
    goto end;
1874
2581
  }
1875
2582
  
1887
2594
    config.publish_domain = 0;
1888
2595
    
1889
2596
    /* Allocate a new server */
1890
 
    mc.server = avahi_server_new(avahi_simple_poll_get
1891
 
                                 (mc.simple_poll), &config, NULL,
1892
 
                                 NULL, &error);
 
2597
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
2598
                                 &config, NULL, NULL, &ret_errno);
1893
2599
    
1894
2600
    /* Free the Avahi configuration data */
1895
2601
    avahi_server_config_free(&config);
1897
2603
  
1898
2604
  /* Check if creating the Avahi server object succeeded */
1899
2605
  if(mc.server == NULL){
1900
 
    fprintf(stderr, "Failed to create Avahi server: %s\n",
1901
 
            avahi_strerror(error));
 
2606
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
 
2607
                 avahi_strerror(ret_errno));
1902
2608
    exitcode = EX_UNAVAILABLE;
1903
2609
    goto end;
1904
2610
  }
1910
2616
  /* Create the Avahi service browser */
1911
2617
  sb = avahi_s_service_browser_new(mc.server, if_index,
1912
2618
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1913
 
                                   NULL, 0, browse_callback, NULL);
 
2619
                                   NULL, 0, browse_callback,
 
2620
                                   (void *)&mc);
1914
2621
  if(sb == NULL){
1915
 
    fprintf(stderr, "Failed to create service browser: %s\n",
1916
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
2622
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
 
2623
                 avahi_strerror(avahi_server_errno(mc.server)));
1917
2624
    exitcode = EX_UNAVAILABLE;
1918
2625
    goto end;
1919
2626
  }
1925
2632
  /* Run the main loop */
1926
2633
  
1927
2634
  if(debug){
1928
 
    fprintf(stderr, "Starting Avahi loop search\n");
 
2635
    fprintf_plus(stderr, "Starting Avahi loop search\n");
1929
2636
  }
1930
 
 
1931
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
1932
 
                                (int)(retry_interval * 1000));
 
2637
  
 
2638
  ret = avahi_loop_with_timeout(simple_poll,
 
2639
                                (int)(retry_interval * 1000), &mc);
1933
2640
  if(debug){
1934
 
    fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
1935
 
            (ret == 0) ? "successfully" : "with error");
 
2641
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
 
2642
                 (ret == 0) ? "successfully" : "with error");
1936
2643
  }
1937
2644
  
1938
2645
 end:
1939
2646
  
1940
2647
  if(debug){
1941
 
    fprintf(stderr, "%s exiting\n", argv[0]);
 
2648
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
1942
2649
  }
1943
2650
  
1944
2651
  /* Cleanup things */
 
2652
  free(mc.interfaces);
 
2653
  
1945
2654
  if(sb != NULL)
1946
2655
    avahi_s_service_browser_free(sb);
1947
2656
  
1948
2657
  if(mc.server != NULL)
1949
2658
    avahi_server_free(mc.server);
1950
2659
  
1951
 
  if(mc.simple_poll != NULL)
1952
 
    avahi_simple_poll_free(mc.simple_poll);
 
2660
  if(simple_poll != NULL)
 
2661
    avahi_simple_poll_free(simple_poll);
1953
2662
  
1954
2663
  if(gnutls_initialized){
1955
2664
    gnutls_certificate_free_credentials(mc.cred);
1960
2669
  if(gpgme_initialized){
1961
2670
    gpgme_release(mc.ctx);
1962
2671
  }
1963
 
 
 
2672
  
1964
2673
  /* Cleans up the circular linked list of Mandos servers the client
1965
2674
     has seen */
1966
2675
  if(mc.current_server != NULL){
1967
2676
    mc.current_server->prev->next = NULL;
1968
2677
    while(mc.current_server != NULL){
1969
2678
      server *next = mc.current_server->next;
 
2679
#ifdef __GNUC__
 
2680
#pragma GCC diagnostic push
 
2681
#pragma GCC diagnostic ignored "-Wcast-qual"
 
2682
#endif
 
2683
      free((char *)(mc.current_server->ip));
 
2684
#ifdef __GNUC__
 
2685
#pragma GCC diagnostic pop
 
2686
#endif
1970
2687
      free(mc.current_server);
1971
2688
      mc.current_server = next;
1972
2689
    }
1973
2690
  }
1974
2691
  
1975
 
  /* Take down the network interface */
1976
 
  if(take_down_interface){
1977
 
    /* Re-raise priviliges */
1978
 
    errno = 0;
1979
 
    ret = seteuid(0);
1980
 
    if(ret == -1){
1981
 
      perror_plus("seteuid");
 
2692
  /* Re-raise privileges */
 
2693
  {
 
2694
    ret_errno = raise_privileges();
 
2695
    if(ret_errno != 0){
 
2696
      errno = ret_errno;
 
2697
      perror_plus("Failed to raise privileges");
 
2698
    } else {
 
2699
      
 
2700
      /* Run network hooks */
 
2701
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
2702
                        interfaces_hooks : "", delay);
 
2703
      
 
2704
      /* Take down the network interfaces which were brought up */
 
2705
      {
 
2706
        char *interface = NULL;
 
2707
        while((interface=argz_next(interfaces_to_take_down,
 
2708
                                   interfaces_to_take_down_size,
 
2709
                                   interface))){
 
2710
          ret_errno = take_down_interface(interface);
 
2711
          if(ret_errno != 0){
 
2712
            errno = ret_errno;
 
2713
            perror_plus("Failed to take down interface");
 
2714
          }
 
2715
        }
 
2716
        if(debug and (interfaces_to_take_down == NULL)){
 
2717
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
2718
                       " down\n");
 
2719
        }
 
2720
      }
1982
2721
    }
1983
 
    if(geteuid() == 0){
1984
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1985
 
      if(ret == -1){
1986
 
        perror_plus("ioctl SIOCGIFFLAGS");
1987
 
      } else if(network.ifr_flags & IFF_UP) {
1988
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1989
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
1990
 
        if(ret == -1){
1991
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1992
 
        }
1993
 
      }
1994
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1995
 
      if(ret == -1){
1996
 
        perror_plus("close");
1997
 
      }
1998
 
      /* Lower privileges permanently */
1999
 
      errno = 0;
2000
 
      ret = setuid(uid);
2001
 
      if(ret == -1){
2002
 
        perror_plus("setuid");
2003
 
      }
 
2722
    
 
2723
    ret_errno = lower_privileges_permanently();
 
2724
    if(ret_errno != 0){
 
2725
      errno = ret_errno;
 
2726
      perror_plus("Failed to lower privileges permanently");
2004
2727
    }
2005
2728
  }
2006
2729
  
 
2730
  free(interfaces_to_take_down);
 
2731
  free(interfaces_hooks);
 
2732
  
2007
2733
  /* Removes the GPGME temp directory and all files inside */
2008
 
  if(tempdir_created){
 
2734
  if(tempdir != NULL){
2009
2735
    struct dirent **direntries = NULL;
2010
 
    struct dirent *direntry = NULL;
2011
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2012
 
                             alphasort);
2013
 
    if (numentries > 0){
2014
 
      for(int i = 0; i < numentries; i++){
2015
 
        direntry = direntries[i];
2016
 
        char *fullname = NULL;
2017
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2018
 
                       direntry->d_name);
2019
 
        if(ret < 0){
2020
 
          perror_plus("asprintf");
2021
 
          continue;
2022
 
        }
2023
 
        ret = remove(fullname);
2024
 
        if(ret == -1){
2025
 
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
2026
 
                  strerror(errno));
2027
 
        }
2028
 
        free(fullname);
 
2736
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
 
2737
                                                  O_NOFOLLOW));
 
2738
    if(tempdir_fd == -1){
 
2739
      perror_plus("open");
 
2740
    } else {
 
2741
#ifdef __GLIBC__
 
2742
#if __GLIBC_PREREQ(2, 15)
 
2743
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
2744
                                 notdotentries, alphasort);
 
2745
#else  /* not __GLIBC_PREREQ(2, 15) */
 
2746
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2747
                               alphasort);
 
2748
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
2749
#else   /* not __GLIBC__ */
 
2750
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2751
                               alphasort);
 
2752
#endif  /* not __GLIBC__ */
 
2753
      if(numentries >= 0){
 
2754
        for(int i = 0; i < numentries; i++){
 
2755
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
2756
          if(ret == -1){
 
2757
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
2758
                         " \"%s\", 0): %s\n", tempdir,
 
2759
                         direntries[i]->d_name, strerror(errno));
 
2760
          }
 
2761
          free(direntries[i]);
 
2762
        }
 
2763
        
 
2764
        /* need to clean even if 0 because man page doesn't specify */
 
2765
        free(direntries);
 
2766
        if(numentries == -1){
 
2767
          perror_plus("scandir");
 
2768
        }
 
2769
        ret = rmdir(tempdir);
 
2770
        if(ret == -1 and errno != ENOENT){
 
2771
          perror_plus("rmdir");
 
2772
        }
2029
2773
      }
2030
 
    }
2031
 
 
2032
 
    /* need to clean even if 0 because man page doesn't specify */
2033
 
    free(direntries);
2034
 
    if (numentries == -1){
2035
 
      perror_plus("scandir");
2036
 
    }
2037
 
    ret = rmdir(tempdir);
2038
 
    if(ret == -1 and errno != ENOENT){
2039
 
      perror_plus("rmdir");
 
2774
      TEMP_FAILURE_RETRY(close(tempdir_fd));
2040
2775
    }
2041
2776
  }
2042
2777