/mandos/release

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2015-07-20 03:03:33 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

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-2015 Teddy Hogeborn
 
13
 * Copyright © 2008-2015 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
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() */
48
48
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
 
49
#include <string.h>             /* strcmp(), strlen(), strerror(),
 
50
                                   asprintf(), strcpy() */
51
51
#include <sys/ioctl.h>          /* ioctl */
52
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
53
                                   sockaddr_in6, PF_INET6,
55
55
                                   opendir(), DIR */
56
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,
87
88
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
89
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
89
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() */
90
98
 
91
99
#ifdef __linux__
92
100
#include <sys/klog.h>           /* klogctl() */
110
118
                                   init_gnutls_session(),
111
119
                                   GNUTLS_* */
112
120
#include <gnutls/openpgp.h>
113
 
                          /* gnutls_certificate_set_openpgp_key_file(),
114
 
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
121
                         /* gnutls_certificate_set_openpgp_key_file(),
 
122
                            GNUTLS_OPENPGP_FMT_BASE64 */
115
123
 
116
124
/* GPGME */
117
125
#include <gpgme.h>              /* All GPGME types, constants and
134
142
static const char sys_class_net[] = "/sys/class/net";
135
143
char *connect_to = NULL;
136
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
 
146
uid_t uid = 65534;
 
147
gid_t gid = 65534;
137
148
 
138
149
/* Doubly linked list that need to be circularly linked when used */
139
150
typedef struct server{
140
151
  const char *ip;
141
 
  uint16_t port;
 
152
  in_port_t port;
142
153
  AvahiIfIndex if_index;
143
154
  int af;
144
155
  struct timespec last_seen;
148
159
 
149
160
/* Used for passing in values through the Avahi callback functions */
150
161
typedef struct {
151
 
  AvahiSimplePoll *simple_poll;
152
162
  AvahiServer *server;
153
163
  gnutls_certificate_credentials_t cred;
154
164
  unsigned int dh_bits;
156
166
  const char *priority;
157
167
  gpgme_ctx_t ctx;
158
168
  server *current_server;
 
169
  char *interfaces;
 
170
  size_t interfaces_size;
159
171
} mandos_context;
160
172
 
161
 
/* global context so signal handler can reach it*/
162
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
163
 
                      .dh_bits = 1024, .priority = "SECURE256"
164
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
165
 
                      .current_server = NULL };
 
173
/* global so signal handler can reach it*/
 
174
AvahiSimplePoll *simple_poll;
166
175
 
167
176
sig_atomic_t quit_now = 0;
168
177
int signal_received = 0;
169
178
 
170
179
/* Function to use when printing errors */
171
180
void perror_plus(const char *print_text){
 
181
  int e = errno;
172
182
  fprintf(stderr, "Mandos plugin %s: ",
173
183
          program_invocation_short_name);
 
184
  errno = e;
174
185
  perror(print_text);
175
186
}
176
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
 
177
198
/*
178
199
 * Make additional room in "buffer" for at least BUFFER_SIZE more
179
200
 * bytes. "buffer_capacity" is how much is currently allocated,
180
201
 * "buffer_length" is how much is already used.
181
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
182
204
size_t incbuffer(char **buffer, size_t buffer_length,
183
 
                  size_t buffer_capacity){
 
205
                 size_t buffer_capacity){
184
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
185
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
186
 
    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;
187
213
      return 0;
188
214
    }
 
215
    *buffer = new_buf;
189
216
    buffer_capacity += BUFFER_SIZE;
190
217
  }
191
218
  return buffer_capacity;
192
219
}
193
220
 
194
221
/* Add server to set of servers to retry periodically */
195
 
int add_server(const char *ip, uint16_t port,
196
 
                 AvahiIfIndex if_index,
197
 
                 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){
198
225
  int ret;
199
226
  server *new_server = malloc(sizeof(server));
200
227
  if(new_server == NULL){
201
228
    perror_plus("malloc");
202
 
    return -1;
 
229
    return false;
203
230
  }
204
231
  *new_server = (server){ .ip = strdup(ip),
205
 
                         .port = port,
206
 
                         .if_index = if_index,
207
 
                         .af = af };
 
232
                          .port = port,
 
233
                          .if_index = if_index,
 
234
                          .af = af };
208
235
  if(new_server->ip == NULL){
209
236
    perror_plus("strdup");
210
 
    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;
211
253
  }
212
254
  /* Special case of first server */
213
 
  if (mc.current_server == NULL){
 
255
  if(*current_server == NULL){
214
256
    new_server->next = new_server;
215
257
    new_server->prev = new_server;
216
 
    mc.current_server = new_server;
217
 
  /* Place the new server last in the list */
 
258
    *current_server = new_server;
218
259
  } else {
219
 
    new_server->next = mc.current_server;
220
 
    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;
221
263
    new_server->prev->next = new_server;
222
 
    mc.current_server->prev = new_server;
223
 
  }
224
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
225
 
  if(ret == -1){
226
 
    perror_plus("clock_gettime");
227
 
    return -1;
228
 
  }
229
 
  return 0;
 
264
    (*current_server)->prev = new_server;
 
265
  }
 
266
  return true;
230
267
}
231
268
 
232
269
/* 
233
270
 * Initialize GPGME.
234
271
 */
235
 
static bool init_gpgme(const char *seckey,
236
 
                       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){
237
277
  gpgme_error_t rc;
238
278
  gpgme_engine_info_t engine_info;
239
279
  
240
 
  
241
280
  /*
242
281
   * Helper function to insert pub and seckey to the engine keyring.
243
282
   */
244
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
245
284
    int ret;
246
285
    int fd;
247
286
    gpgme_data_t pgp_data;
254
293
    
255
294
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
256
295
    if(rc != GPG_ERR_NO_ERROR){
257
 
      fprintf(stderr, "Mandos plugin mandos-client: "
258
 
              "bad gpgme_data_new_from_fd: %s: %s\n",
259
 
              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));
260
298
      return false;
261
299
    }
262
300
    
263
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
301
    rc = gpgme_op_import(mc->ctx, pgp_data);
264
302
    if(rc != GPG_ERR_NO_ERROR){
265
 
      fprintf(stderr, "Mandos plugin mandos-client: "
266
 
              "bad gpgme_op_import: %s: %s\n",
267
 
              gpgme_strsource(rc), gpgme_strerror(rc));
 
303
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
 
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
268
305
      return false;
269
306
    }
270
307
    
271
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
308
    ret = close(fd);
272
309
    if(ret == -1){
273
310
      perror_plus("close");
274
311
    }
277
314
  }
278
315
  
279
316
  if(debug){
280
 
    fprintf(stderr, "Mandos plugin mandos-client: "
281
 
            "Initializing GPGME\n");
 
317
    fprintf_plus(stderr, "Initializing GPGME\n");
282
318
  }
283
319
  
284
320
  /* Init GPGME */
285
321
  gpgme_check_version(NULL);
286
322
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
287
323
  if(rc != GPG_ERR_NO_ERROR){
288
 
    fprintf(stderr, "Mandos plugin mandos-client: "
289
 
            "bad gpgme_engine_check_version: %s: %s\n",
290
 
            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));
291
326
    return false;
292
327
  }
293
328
  
294
329
  /* Set GPGME home directory for the OpenPGP engine only */
295
330
  rc = gpgme_get_engine_info(&engine_info);
296
331
  if(rc != GPG_ERR_NO_ERROR){
297
 
    fprintf(stderr, "Mandos plugin mandos-client: "
298
 
            "bad gpgme_get_engine_info: %s: %s\n",
299
 
            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));
300
334
    return false;
301
335
  }
302
336
  while(engine_info != NULL){
308
342
    engine_info = engine_info->next;
309
343
  }
310
344
  if(engine_info == NULL){
311
 
    fprintf(stderr, "Mandos plugin mandos-client: "
312
 
            "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);
313
347
    return false;
314
348
  }
315
349
  
316
350
  /* Create new GPGME "context" */
317
 
  rc = gpgme_new(&(mc.ctx));
 
351
  rc = gpgme_new(&(mc->ctx));
318
352
  if(rc != GPG_ERR_NO_ERROR){
319
 
    fprintf(stderr, "Mandos plugin mandos-client: "
320
 
            "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
321
 
            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));
322
356
    return false;
323
357
  }
324
358
  
333
367
 * Decrypt OpenPGP data.
334
368
 * Returns -1 on error
335
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
336
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
337
372
                                  size_t crypto_size,
338
 
                                  char **plaintext){
 
373
                                  char **plaintext,
 
374
                                  mandos_context *mc){
339
375
  gpgme_data_t dh_crypto, dh_plain;
340
376
  gpgme_error_t rc;
341
377
  ssize_t ret;
343
379
  ssize_t plaintext_length = 0;
344
380
  
345
381
  if(debug){
346
 
    fprintf(stderr, "Mandos plugin mandos-client: "
347
 
            "Trying to decrypt OpenPGP data\n");
 
382
    fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
348
383
  }
349
384
  
350
385
  /* Create new GPGME data buffer from memory cryptotext */
351
386
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
352
387
                               0);
353
388
  if(rc != GPG_ERR_NO_ERROR){
354
 
    fprintf(stderr, "Mandos plugin mandos-client: "
355
 
            "bad gpgme_data_new_from_mem: %s: %s\n",
356
 
            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));
357
391
    return -1;
358
392
  }
359
393
  
360
394
  /* Create new empty GPGME data buffer for the plaintext */
361
395
  rc = gpgme_data_new(&dh_plain);
362
396
  if(rc != GPG_ERR_NO_ERROR){
363
 
    fprintf(stderr, "Mandos plugin mandos-client: "
364
 
            "bad gpgme_data_new: %s: %s\n",
365
 
            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));
366
400
    gpgme_data_release(dh_crypto);
367
401
    return -1;
368
402
  }
369
403
  
370
404
  /* Decrypt data from the cryptotext data buffer to the plaintext
371
405
     data buffer */
372
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
406
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
373
407
  if(rc != GPG_ERR_NO_ERROR){
374
 
    fprintf(stderr, "Mandos plugin mandos-client: "
375
 
            "bad gpgme_op_decrypt: %s: %s\n",
376
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
408
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
409
                 gpgme_strsource(rc), gpgme_strerror(rc));
377
410
    plaintext_length = -1;
378
411
    if(debug){
379
412
      gpgme_decrypt_result_t result;
380
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
413
      result = gpgme_op_decrypt_result(mc->ctx);
381
414
      if(result == NULL){
382
 
        fprintf(stderr, "Mandos plugin mandos-client: "
383
 
                "gpgme_op_decrypt_result failed\n");
 
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
384
416
      } else {
385
 
        fprintf(stderr, "Mandos plugin mandos-client: "
386
 
                "Unsupported algorithm: %s\n",
387
 
                result->unsupported_algorithm);
388
 
        fprintf(stderr, "Mandos plugin mandos-client: "
389
 
                "Wrong key usage: %u\n",
390
 
                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);
391
421
        if(result->file_name != NULL){
392
 
          fprintf(stderr, "Mandos plugin mandos-client: "
393
 
                  "File name: %s\n", result->file_name);
 
422
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
394
423
        }
395
424
        gpgme_recipient_t recipient;
396
425
        recipient = result->recipients;
397
426
        while(recipient != NULL){
398
 
          fprintf(stderr, "Mandos plugin mandos-client: "
399
 
                  "Public key algorithm: %s\n",
400
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
401
 
          fprintf(stderr, "Mandos plugin mandos-client: "
402
 
                  "Key ID: %s\n", recipient->keyid);
403
 
          fprintf(stderr, "Mandos plugin mandos-client: "
404
 
                  "Secret key available: %s\n",
405
 
                  recipient->status == GPG_ERR_NO_SECKEY
406
 
                  ? "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");
407
434
          recipient = recipient->next;
408
435
        }
409
436
      }
412
439
  }
413
440
  
414
441
  if(debug){
415
 
    fprintf(stderr, "Mandos plugin mandos-client: "
416
 
            "Decryption of OpenPGP data succeeded\n");
 
442
    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
417
443
  }
418
444
  
419
445
  /* Seek back to the beginning of the GPGME plaintext data buffer */
426
452
  *plaintext = NULL;
427
453
  while(true){
428
454
    plaintext_capacity = incbuffer(plaintext,
429
 
                                      (size_t)plaintext_length,
430
 
                                      plaintext_capacity);
 
455
                                   (size_t)plaintext_length,
 
456
                                   plaintext_capacity);
431
457
    if(plaintext_capacity == 0){
432
 
        perror_plus("incbuffer");
433
 
        plaintext_length = -1;
434
 
        goto decrypt_end;
 
458
      perror_plus("incbuffer");
 
459
      plaintext_length = -1;
 
460
      goto decrypt_end;
435
461
    }
436
462
    
437
463
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
450
476
  }
451
477
  
452
478
  if(debug){
453
 
    fprintf(stderr, "Mandos plugin mandos-client: "
454
 
            "Decrypted password is: ");
 
479
    fprintf_plus(stderr, "Decrypted password is: ");
455
480
    for(ssize_t i = 0; i < plaintext_length; i++){
456
481
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
457
482
    }
468
493
  return plaintext_length;
469
494
}
470
495
 
471
 
static const char * safer_gnutls_strerror(int value){
472
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
473
 
                                               -Wunreachable-code */
474
 
  if(ret == NULL)
475
 
    ret = "(unknown)";
476
 
  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);
477
507
}
478
508
 
479
509
/* GnuTLS log function callback */
 
510
__attribute__((nonnull))
480
511
static void debuggnutls(__attribute__((unused)) int level,
481
512
                        const char* string){
482
 
  fprintf(stderr, "Mandos plugin mandos-client: GnuTLS: %s", string);
 
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
483
514
}
484
515
 
 
516
__attribute__((nonnull, warn_unused_result))
485
517
static int init_gnutls_global(const char *pubkeyfilename,
486
 
                              const char *seckeyfilename){
 
518
                              const char *seckeyfilename,
 
519
                              const char *dhparamsfilename,
 
520
                              mandos_context *mc){
487
521
  int ret;
 
522
  unsigned int uret;
488
523
  
489
524
  if(debug){
490
 
    fprintf(stderr, "Mandos plugin mandos-client: "
491
 
            "Initializing GnuTLS\n");
 
525
    fprintf_plus(stderr, "Initializing GnuTLS\n");
492
526
  }
493
527
  
494
528
  ret = gnutls_global_init();
495
529
  if(ret != GNUTLS_E_SUCCESS){
496
 
    fprintf(stderr, "Mandos plugin mandos-client: "
497
 
            "GnuTLS global_init: %s\n", safer_gnutls_strerror(ret));
 
530
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
531
                 safer_gnutls_strerror(ret));
498
532
    return -1;
499
533
  }
500
534
  
507
541
  }
508
542
  
509
543
  /* OpenPGP credentials */
510
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
544
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
511
545
  if(ret != GNUTLS_E_SUCCESS){
512
 
    fprintf(stderr, "Mandos plugin mandos-client: "
513
 
            "GnuTLS memory error: %s\n", safer_gnutls_strerror(ret));
 
546
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
 
547
                 safer_gnutls_strerror(ret));
514
548
    gnutls_global_deinit();
515
549
    return -1;
516
550
  }
517
551
  
518
552
  if(debug){
519
 
    fprintf(stderr, "Mandos plugin mandos-client: "
520
 
            "Attempting to use OpenPGP public key %s and"
521
 
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
522
 
            seckeyfilename);
 
553
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
554
                 " secret key %s as GnuTLS credentials\n",
 
555
                 pubkeyfilename,
 
556
                 seckeyfilename);
523
557
  }
524
558
  
525
559
  ret = gnutls_certificate_set_openpgp_key_file
526
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
560
    (mc->cred, pubkeyfilename, seckeyfilename,
527
561
     GNUTLS_OPENPGP_FMT_BASE64);
528
562
  if(ret != GNUTLS_E_SUCCESS){
529
 
    fprintf(stderr,
530
 
            "Mandos plugin mandos-client: "
531
 
            "Error[%d] while reading the OpenPGP key pair ('%s',"
532
 
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
533
 
    fprintf(stderr, "Mandos plugin mandos-client: "
534
 
            "The GnuTLS error is: %s\n", safer_gnutls_strerror(ret));
 
563
    fprintf_plus(stderr,
 
564
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
565
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
566
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
 
567
                 safer_gnutls_strerror(ret));
535
568
    goto globalfail;
536
569
  }
537
570
  
538
571
  /* GnuTLS server initialization */
539
 
  ret = gnutls_dh_params_init(&mc.dh_params);
540
 
  if(ret != GNUTLS_E_SUCCESS){
541
 
    fprintf(stderr, "Mandos plugin mandos-client: "
542
 
            "Error in GnuTLS DH parameter initialization:"
543
 
            " %s\n", safer_gnutls_strerror(ret));
544
 
    goto globalfail;
545
 
  }
546
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
547
 
  if(ret != GNUTLS_E_SUCCESS){
548
 
    fprintf(stderr, "Mandos plugin mandos-client: "
549
 
            "Error in GnuTLS prime generation: %s\n",
550
 
            safer_gnutls_strerror(ret));
551
 
    goto globalfail;
552
 
  }
553
 
  
554
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
572
  ret = gnutls_dh_params_init(&mc->dh_params);
 
573
  if(ret != GNUTLS_E_SUCCESS){
 
574
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
 
575
                 " initialization: %s\n",
 
576
                 safer_gnutls_strerror(ret));
 
577
    goto globalfail;
 
578
  }
 
579
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
580
  if(dhparamsfilename != NULL){
 
581
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
582
    do {
 
583
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
584
      if(dhpfile == -1){
 
585
        perror_plus("open");
 
586
        dhparamsfilename = NULL;
 
587
        break;
 
588
      }
 
589
      size_t params_capacity = 0;
 
590
      while(true){
 
591
        params_capacity = incbuffer((char **)&params.data,
 
592
                                    (size_t)params.size,
 
593
                                    (size_t)params_capacity);
 
594
        if(params_capacity == 0){
 
595
          perror_plus("incbuffer");
 
596
          free(params.data);
 
597
          params.data = NULL;
 
598
          dhparamsfilename = NULL;
 
599
          break;
 
600
        }
 
601
        ssize_t bytes_read = read(dhpfile,
 
602
                                  params.data + params.size,
 
603
                                  BUFFER_SIZE);
 
604
        /* EOF */
 
605
        if(bytes_read == 0){
 
606
          break;
 
607
        }
 
608
        /* check bytes_read for failure */
 
609
        if(bytes_read < 0){
 
610
          perror_plus("read");
 
611
          free(params.data);
 
612
          params.data = NULL;
 
613
          dhparamsfilename = NULL;
 
614
          break;
 
615
        }
 
616
        params.size += (unsigned int)bytes_read;
 
617
      }
 
618
      if(params.data == NULL){
 
619
        dhparamsfilename = NULL;
 
620
      }
 
621
      if(dhparamsfilename == NULL){
 
622
        break;
 
623
      }
 
624
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
 
625
                                          GNUTLS_X509_FMT_PEM);
 
626
      if(ret != GNUTLS_E_SUCCESS){
 
627
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
 
628
                     " \"%s\": %s\n", dhparamsfilename,
 
629
                     safer_gnutls_strerror(ret));
 
630
        dhparamsfilename = NULL;
 
631
      }
 
632
    } while(false);
 
633
  }
 
634
  if(dhparamsfilename == NULL){
 
635
    if(mc->dh_bits == 0){
 
636
      /* Find out the optimal number of DH bits */
 
637
      /* Try to read the private key file */
 
638
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
639
      do {
 
640
        int secfile = open(seckeyfilename, O_RDONLY);
 
641
        if(secfile == -1){
 
642
          perror_plus("open");
 
643
          break;
 
644
        }
 
645
        size_t buffer_capacity = 0;
 
646
        while(true){
 
647
          buffer_capacity = incbuffer((char **)&buffer.data,
 
648
                                      (size_t)buffer.size,
 
649
                                      (size_t)buffer_capacity);
 
650
          if(buffer_capacity == 0){
 
651
            perror_plus("incbuffer");
 
652
            free(buffer.data);
 
653
            buffer.data = NULL;
 
654
            break;
 
655
          }
 
656
          ssize_t bytes_read = read(secfile,
 
657
                                    buffer.data + buffer.size,
 
658
                                    BUFFER_SIZE);
 
659
          /* EOF */
 
660
          if(bytes_read == 0){
 
661
            break;
 
662
          }
 
663
          /* check bytes_read for failure */
 
664
          if(bytes_read < 0){
 
665
            perror_plus("read");
 
666
            free(buffer.data);
 
667
            buffer.data = NULL;
 
668
            break;
 
669
          }
 
670
          buffer.size += (unsigned int)bytes_read;
 
671
        }
 
672
        close(secfile);
 
673
      } while(false);
 
674
      /* If successful, use buffer to parse private key */
 
675
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
676
      if(buffer.data != NULL){
 
677
        {
 
678
          gnutls_openpgp_privkey_t privkey = NULL;
 
679
          ret = gnutls_openpgp_privkey_init(&privkey);
 
680
          if(ret != GNUTLS_E_SUCCESS){
 
681
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
682
                         " structure: %s",
 
683
                         safer_gnutls_strerror(ret));
 
684
            free(buffer.data);
 
685
            buffer.data = NULL;
 
686
          } else {
 
687
            ret = gnutls_openpgp_privkey_import
 
688
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
 
689
            if(ret != GNUTLS_E_SUCCESS){
 
690
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
691
                           safer_gnutls_strerror(ret));
 
692
              privkey = NULL;
 
693
            }
 
694
            free(buffer.data);
 
695
            buffer.data = NULL;
 
696
            if(privkey != NULL){
 
697
              /* Use private key to suggest an appropriate
 
698
                 sec_param */
 
699
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
700
              gnutls_openpgp_privkey_deinit(privkey);
 
701
              if(debug){
 
702
                fprintf_plus(stderr, "This OpenPGP key implies using"
 
703
                             " a GnuTLS security parameter \"%s\".\n",
 
704
                             safe_string(gnutls_sec_param_get_name
 
705
                                         (sec_param)));
 
706
              }
 
707
            }
 
708
          }
 
709
        }
 
710
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
711
          /* Err on the side of caution */
 
712
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
713
          if(debug){
 
714
            fprintf_plus(stderr, "Falling back to security parameter"
 
715
                         " \"%s\"\n",
 
716
                         safe_string(gnutls_sec_param_get_name
 
717
                                     (sec_param)));
 
718
          }
 
719
        }
 
720
      }
 
721
      uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
722
      if(uret != 0){
 
723
        mc->dh_bits = uret;
 
724
        if(debug){
 
725
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
726
                       " implies %u DH bits; using that.\n",
 
727
                       safe_string(gnutls_sec_param_get_name
 
728
                                   (sec_param)),
 
729
                       mc->dh_bits);
 
730
        }
 
731
      } else {
 
732
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
733
                     " bits for security parameter \"%s\"): %s\n",
 
734
                     safe_string(gnutls_sec_param_get_name
 
735
                                 (sec_param)),
 
736
                     safer_gnutls_strerror(ret));
 
737
        goto globalfail;
 
738
      }
 
739
    } else if(debug){
 
740
      fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
741
                   mc->dh_bits);
 
742
    }
 
743
    ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
744
    if(ret != GNUTLS_E_SUCCESS){
 
745
      fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
 
746
                   " bits): %s\n", mc->dh_bits,
 
747
                   safer_gnutls_strerror(ret));
 
748
      goto globalfail;
 
749
    }
 
750
  }
 
751
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
555
752
  
556
753
  return 0;
557
754
  
558
755
 globalfail:
559
756
  
560
 
  gnutls_certificate_free_credentials(mc.cred);
 
757
  gnutls_certificate_free_credentials(mc->cred);
561
758
  gnutls_global_deinit();
562
 
  gnutls_dh_params_deinit(mc.dh_params);
 
759
  gnutls_dh_params_deinit(mc->dh_params);
563
760
  return -1;
564
761
}
565
762
 
566
 
static int init_gnutls_session(gnutls_session_t *session){
 
763
__attribute__((nonnull, warn_unused_result))
 
764
static int init_gnutls_session(gnutls_session_t *session,
 
765
                               mandos_context *mc){
567
766
  int ret;
568
767
  /* GnuTLS session creation */
569
768
  do {
573
772
    }
574
773
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
575
774
  if(ret != GNUTLS_E_SUCCESS){
576
 
    fprintf(stderr, "Mandos plugin mandos-client: "
577
 
            "Error in GnuTLS session initialization: %s\n",
578
 
            safer_gnutls_strerror(ret));
 
775
    fprintf_plus(stderr,
 
776
                 "Error in GnuTLS session initialization: %s\n",
 
777
                 safer_gnutls_strerror(ret));
579
778
  }
580
779
  
581
780
  {
582
781
    const char *err;
583
782
    do {
584
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
783
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
585
784
      if(quit_now){
586
785
        gnutls_deinit(*session);
587
786
        return -1;
588
787
      }
589
788
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
590
789
    if(ret != GNUTLS_E_SUCCESS){
591
 
      fprintf(stderr, "Mandos plugin mandos-client: "
592
 
              "Syntax error at: %s\n", err);
593
 
      fprintf(stderr, "Mandos plugin mandos-client: "
594
 
              "GnuTLS error: %s\n", safer_gnutls_strerror(ret));
 
790
      fprintf_plus(stderr, "Syntax error at: %s\n", err);
 
791
      fprintf_plus(stderr, "GnuTLS error: %s\n",
 
792
                   safer_gnutls_strerror(ret));
595
793
      gnutls_deinit(*session);
596
794
      return -1;
597
795
    }
599
797
  
600
798
  do {
601
799
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
602
 
                                 mc.cred);
 
800
                                 mc->cred);
603
801
    if(quit_now){
604
802
      gnutls_deinit(*session);
605
803
      return -1;
606
804
    }
607
805
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
608
806
  if(ret != GNUTLS_E_SUCCESS){
609
 
    fprintf(stderr, "Mandos plugin mandos-client: "
610
 
            "Error setting GnuTLS credentials: %s\n",
611
 
            safer_gnutls_strerror(ret));
 
807
    fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
 
808
                 safer_gnutls_strerror(ret));
612
809
    gnutls_deinit(*session);
613
810
    return -1;
614
811
  }
616
813
  /* ignore client certificate if any. */
617
814
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
618
815
  
619
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
620
 
  
621
816
  return 0;
622
817
}
623
818
 
625
820
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
626
821
                      __attribute__((unused)) const char *txt){}
627
822
 
 
823
/* Set effective uid to 0, return errno */
 
824
__attribute__((warn_unused_result))
 
825
error_t raise_privileges(void){
 
826
  error_t old_errno = errno;
 
827
  error_t ret_errno = 0;
 
828
  if(seteuid(0) == -1){
 
829
    ret_errno = errno;
 
830
  }
 
831
  errno = old_errno;
 
832
  return ret_errno;
 
833
}
 
834
 
 
835
/* Set effective and real user ID to 0.  Return errno. */
 
836
__attribute__((warn_unused_result))
 
837
error_t raise_privileges_permanently(void){
 
838
  error_t old_errno = errno;
 
839
  error_t ret_errno = raise_privileges();
 
840
  if(ret_errno != 0){
 
841
    errno = old_errno;
 
842
    return ret_errno;
 
843
  }
 
844
  if(setuid(0) == -1){
 
845
    ret_errno = errno;
 
846
  }
 
847
  errno = old_errno;
 
848
  return ret_errno;
 
849
}
 
850
 
 
851
/* Set effective user ID to unprivileged saved user ID */
 
852
__attribute__((warn_unused_result))
 
853
error_t lower_privileges(void){
 
854
  error_t old_errno = errno;
 
855
  error_t ret_errno = 0;
 
856
  if(seteuid(uid) == -1){
 
857
    ret_errno = errno;
 
858
  }
 
859
  errno = old_errno;
 
860
  return ret_errno;
 
861
}
 
862
 
 
863
/* Lower privileges permanently */
 
864
__attribute__((warn_unused_result))
 
865
error_t lower_privileges_permanently(void){
 
866
  error_t old_errno = errno;
 
867
  error_t ret_errno = 0;
 
868
  if(setuid(uid) == -1){
 
869
    ret_errno = errno;
 
870
  }
 
871
  errno = old_errno;
 
872
  return ret_errno;
 
873
}
 
874
 
 
875
/* Helper function to add_local_route() and delete_local_route() */
 
876
__attribute__((nonnull, warn_unused_result))
 
877
static bool add_delete_local_route(const bool add,
 
878
                                   const char *address,
 
879
                                   AvahiIfIndex if_index){
 
880
  int ret;
 
881
  char helper[] = "mandos-client-iprouteadddel";
 
882
  char add_arg[] = "add";
 
883
  char delete_arg[] = "delete";
 
884
  char debug_flag[] = "--debug";
 
885
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
 
886
  if(pluginhelperdir == NULL){
 
887
    if(debug){
 
888
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
 
889
                   " variable not set; cannot run helper\n");
 
890
    }
 
891
    return false;
 
892
  }
 
893
  
 
894
  char interface[IF_NAMESIZE];
 
895
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
896
    perror_plus("if_indextoname");
 
897
    return false;
 
898
  }
 
899
  
 
900
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
901
  if(devnull == -1){
 
902
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
903
    return false;
 
904
  }
 
905
  pid_t pid = fork();
 
906
  if(pid == 0){
 
907
    /* Child */
 
908
    /* Raise privileges */
 
909
    errno = raise_privileges_permanently();
 
910
    if(errno != 0){
 
911
      perror_plus("Failed to raise privileges");
 
912
      /* _exit(EX_NOPERM); */
 
913
    } else {
 
914
      /* Set group */
 
915
      errno = 0;
 
916
      ret = setgid(0);
 
917
      if(ret == -1){
 
918
        perror_plus("setgid");
 
919
        _exit(EX_NOPERM);
 
920
      }
 
921
      /* Reset supplementary groups */
 
922
      errno = 0;
 
923
      ret = setgroups(0, NULL);
 
924
      if(ret == -1){
 
925
        perror_plus("setgroups");
 
926
        _exit(EX_NOPERM);
 
927
      }
 
928
    }
 
929
    ret = dup2(devnull, STDIN_FILENO);
 
930
    if(ret == -1){
 
931
      perror_plus("dup2(devnull, STDIN_FILENO)");
 
932
      _exit(EX_OSERR);
 
933
    }
 
934
    ret = close(devnull);
 
935
    if(ret == -1){
 
936
      perror_plus("close");
 
937
      _exit(EX_OSERR);
 
938
    }
 
939
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
940
    if(ret == -1){
 
941
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
942
      _exit(EX_OSERR);
 
943
    }
 
944
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
 
945
                                                    O_RDONLY
 
946
                                                    | O_DIRECTORY
 
947
                                                    | O_PATH
 
948
                                                    | O_CLOEXEC));
 
949
    if(helperdir_fd == -1){
 
950
      perror_plus("open");
 
951
      _exit(EX_UNAVAILABLE);
 
952
    }
 
953
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
 
954
                                                   helper, O_RDONLY));
 
955
    if(helper_fd == -1){
 
956
      perror_plus("openat");
 
957
      close(helperdir_fd);
 
958
      _exit(EX_UNAVAILABLE);
 
959
    }
 
960
    close(helperdir_fd);
 
961
#ifdef __GNUC__
 
962
#pragma GCC diagnostic push
 
963
#pragma GCC diagnostic ignored "-Wcast-qual"
 
964
#endif
 
965
    if(fexecve(helper_fd, (char *const [])
 
966
               { helper, add ? add_arg : delete_arg, (char *)address,
 
967
                   interface, debug ? debug_flag : NULL, NULL },
 
968
               environ) == -1){
 
969
#ifdef __GNUC__
 
970
#pragma GCC diagnostic pop
 
971
#endif
 
972
      perror_plus("fexecve");
 
973
      _exit(EXIT_FAILURE);
 
974
    }
 
975
  }
 
976
  if(pid == -1){
 
977
    perror_plus("fork");
 
978
    return false;
 
979
  }
 
980
  int status;
 
981
  pid_t pret = -1;
 
982
  errno = 0;
 
983
  do {
 
984
    pret = waitpid(pid, &status, 0);
 
985
    if(pret == -1 and errno == EINTR and quit_now){
 
986
      int errno_raising = 0;
 
987
      if((errno = raise_privileges()) != 0){
 
988
        errno_raising = errno;
 
989
        perror_plus("Failed to raise privileges in order to"
 
990
                    " kill helper program");
 
991
      }
 
992
      if(kill(pid, SIGTERM) == -1){
 
993
        perror_plus("kill");
 
994
      }
 
995
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
 
996
        perror_plus("Failed to lower privileges after killing"
 
997
                    " helper program");
 
998
      }
 
999
      return false;
 
1000
    }
 
1001
  } while(pret == -1 and errno == EINTR);
 
1002
  if(pret == -1){
 
1003
    perror_plus("waitpid");
 
1004
    return false;
 
1005
  }
 
1006
  if(WIFEXITED(status)){
 
1007
    if(WEXITSTATUS(status) != 0){
 
1008
      fprintf_plus(stderr, "Error: iprouteadddel exited"
 
1009
                   " with status %d\n", WEXITSTATUS(status));
 
1010
      return false;
 
1011
    }
 
1012
    return true;
 
1013
  }
 
1014
  if(WIFSIGNALED(status)){
 
1015
    fprintf_plus(stderr, "Error: iprouteadddel died by"
 
1016
                 " signal %d\n", WTERMSIG(status));
 
1017
    return false;
 
1018
  }
 
1019
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
 
1020
  return false;
 
1021
}
 
1022
 
 
1023
__attribute__((nonnull, warn_unused_result))
 
1024
static bool add_local_route(const char *address,
 
1025
                            AvahiIfIndex if_index){
 
1026
  if(debug){
 
1027
    fprintf_plus(stderr, "Adding route to %s\n", address);
 
1028
  }
 
1029
  return add_delete_local_route(true, address, if_index);
 
1030
}
 
1031
 
 
1032
__attribute__((nonnull, warn_unused_result))
 
1033
static bool delete_local_route(const char *address,
 
1034
                               AvahiIfIndex if_index){
 
1035
  if(debug){
 
1036
    fprintf_plus(stderr, "Removing route to %s\n", address);
 
1037
  }
 
1038
  return add_delete_local_route(false, address, if_index);
 
1039
}
 
1040
 
628
1041
/* Called when a Mandos server is found */
629
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
1042
__attribute__((nonnull, warn_unused_result))
 
1043
static int start_mandos_communication(const char *ip, in_port_t port,
630
1044
                                      AvahiIfIndex if_index,
631
 
                                      int af){
 
1045
                                      int af, mandos_context *mc){
632
1046
  int ret, tcp_sd = -1;
633
1047
  ssize_t sret;
634
 
  union {
635
 
    struct sockaddr_in in;
636
 
    struct sockaddr_in6 in6;
637
 
  } to;
 
1048
  struct sockaddr_storage to;
638
1049
  char *buffer = NULL;
639
1050
  char *decrypted_buffer = NULL;
640
1051
  size_t buffer_length = 0;
643
1054
  int retval = -1;
644
1055
  gnutls_session_t session;
645
1056
  int pf;                       /* Protocol family */
 
1057
  bool route_added = false;
646
1058
  
647
1059
  errno = 0;
648
1060
  
659
1071
    pf = PF_INET;
660
1072
    break;
661
1073
  default:
662
 
    fprintf(stderr, "Mandos plugin mandos-client: "
663
 
            "Bad address family: %d\n", af);
 
1074
    fprintf_plus(stderr, "Bad address family: %d\n", af);
664
1075
    errno = EINVAL;
665
1076
    return -1;
666
1077
  }
667
1078
  
668
 
  ret = init_gnutls_session(&session);
 
1079
  /* If the interface is specified and we have a list of interfaces */
 
1080
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
1081
    /* Check if the interface is one of the interfaces we are using */
 
1082
    bool match = false;
 
1083
    {
 
1084
      char *interface = NULL;
 
1085
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
1086
                                 interface))){
 
1087
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
1088
          match = true;
 
1089
          break;
 
1090
        }
 
1091
      }
 
1092
    }
 
1093
    if(not match){
 
1094
      /* This interface does not match any in the list, so we don't
 
1095
         connect to the server */
 
1096
      if(debug){
 
1097
        char interface[IF_NAMESIZE];
 
1098
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1099
          perror_plus("if_indextoname");
 
1100
        } else {
 
1101
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
1102
                       " \"%s\"\n",
 
1103
                       if_indextoname((unsigned int)if_index,
 
1104
                                      interface));
 
1105
        }
 
1106
      }
 
1107
      return -1;
 
1108
    }
 
1109
  }
 
1110
  
 
1111
  ret = init_gnutls_session(&session, mc);
669
1112
  if(ret != 0){
670
1113
    return -1;
671
1114
  }
672
1115
  
673
1116
  if(debug){
674
 
    fprintf(stderr, "Mandos plugin mandos-client: "
675
 
            "Setting up a TCP connection to %s, port %" PRIu16
676
 
            "\n", ip, port);
 
1117
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
 
1118
                 PRIuMAX "\n", ip, (uintmax_t)port);
677
1119
  }
678
1120
  
679
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1121
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
680
1122
  if(tcp_sd < 0){
681
1123
    int e = errno;
682
1124
    perror_plus("socket");
689
1131
    goto mandos_end;
690
1132
  }
691
1133
  
692
 
  memset(&to, 0, sizeof(to));
693
1134
  if(af == AF_INET6){
694
 
    to.in6.sin6_family = (sa_family_t)af;
695
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
1135
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1136
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1137
    ret = inet_pton(af, ip, &to6->sin6_addr);
696
1138
  } else {                      /* IPv4 */
697
 
    to.in.sin_family = (sa_family_t)af;
698
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
1139
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1140
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1141
    ret = inet_pton(af, ip, &to4->sin_addr);
699
1142
  }
700
1143
  if(ret < 0 ){
701
1144
    int e = errno;
705
1148
  }
706
1149
  if(ret == 0){
707
1150
    int e = errno;
708
 
    fprintf(stderr, "Mandos plugin mandos-client: "
709
 
            "Bad address: %s\n", ip);
 
1151
    fprintf_plus(stderr, "Bad address: %s\n", ip);
710
1152
    errno = e;
711
1153
    goto mandos_end;
712
1154
  }
713
1155
  if(af == AF_INET6){
714
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
715
 
                                       -Wconversion and
716
 
                                       -Wunreachable-code */
717
 
    
718
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
719
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
720
 
                              -Wunreachable-code*/
 
1156
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
1157
    if(IN6_IS_ADDR_LINKLOCAL
 
1158
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
721
1159
      if(if_index == AVAHI_IF_UNSPEC){
722
 
        fprintf(stderr, "Mandos plugin mandos-client: "
723
 
                "An IPv6 link-local address is incomplete"
724
 
                " without a network interface\n");
 
1160
        fprintf_plus(stderr, "An IPv6 link-local address is"
 
1161
                     " incomplete without a network interface\n");
725
1162
        errno = EINVAL;
726
1163
        goto mandos_end;
727
1164
      }
728
1165
      /* Set the network interface number as scope */
729
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
1166
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
730
1167
    }
731
1168
  } else {
732
 
    to.in.sin_port = htons(port); /* Spurious warnings from
733
 
                                     -Wconversion and
734
 
                                     -Wunreachable-code */
 
1169
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
735
1170
  }
736
1171
  
737
1172
  if(quit_now){
745
1180
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
746
1181
        perror_plus("if_indextoname");
747
1182
      } else {
748
 
        fprintf(stderr, "Mandos plugin mandos-client: "
749
 
                "Connection to: %s%%%s, port %" PRIu16 "\n",
750
 
                ip, interface, port);
 
1183
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
1184
                     "\n", ip, interface, (uintmax_t)port);
751
1185
      }
752
1186
    } else {
753
 
      fprintf(stderr, "Mandos plugin mandos-client: "
754
 
              "Connection to: %s, port %" PRIu16 "\n", ip, port);
 
1187
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
1188
                   ip, (uintmax_t)port);
755
1189
    }
756
1190
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
757
1191
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
758
 
    const char *pcret;
759
 
    if(af == AF_INET6){
760
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
761
 
                        sizeof(addrstr));
762
 
    } else {
763
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
764
 
                        sizeof(addrstr));
765
 
    }
766
 
    if(pcret == NULL){
767
 
      perror_plus("inet_ntop");
768
 
    } else {
769
 
      if(strcmp(addrstr, ip) != 0){
770
 
        fprintf(stderr, "Mandos plugin mandos-client: "
771
 
                "Canonical address form: %s\n", addrstr);
772
 
      }
773
 
    }
774
 
  }
775
 
  
776
 
  if(quit_now){
777
 
    errno = EINTR;
778
 
    goto mandos_end;
779
 
  }
780
 
  
781
 
  if(af == AF_INET6){
782
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
783
 
  } else {
784
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
785
 
  }
786
 
  if(ret < 0){
787
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
788
 
      int e = errno;
789
 
      perror_plus("connect");
790
 
      errno = e;
791
 
    }
792
 
    goto mandos_end;
793
 
  }
794
 
  
795
 
  if(quit_now){
796
 
    errno = EINTR;
797
 
    goto mandos_end;
 
1192
    if(af == AF_INET6){
 
1193
      ret = getnameinfo((struct sockaddr *)&to,
 
1194
                        sizeof(struct sockaddr_in6),
 
1195
                        addrstr, sizeof(addrstr), NULL, 0,
 
1196
                        NI_NUMERICHOST);
 
1197
    } else {
 
1198
      ret = getnameinfo((struct sockaddr *)&to,
 
1199
                        sizeof(struct sockaddr_in),
 
1200
                        addrstr, sizeof(addrstr), NULL, 0,
 
1201
                        NI_NUMERICHOST);
 
1202
    }
 
1203
    if(ret == EAI_SYSTEM){
 
1204
      perror_plus("getnameinfo");
 
1205
    } else if(ret != 0) {
 
1206
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
1207
    } else if(strcmp(addrstr, ip) != 0){
 
1208
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
 
1209
    }
 
1210
  }
 
1211
  
 
1212
  if(quit_now){
 
1213
    errno = EINTR;
 
1214
    goto mandos_end;
 
1215
  }
 
1216
  
 
1217
  while(true){
 
1218
    if(af == AF_INET6){
 
1219
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1220
                    sizeof(struct sockaddr_in6));
 
1221
    } else {
 
1222
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1223
                    sizeof(struct sockaddr_in));
 
1224
    }
 
1225
    if(ret < 0){
 
1226
      if(errno == ENETUNREACH
 
1227
         and if_index != AVAHI_IF_UNSPEC
 
1228
         and connect_to == NULL
 
1229
         and not route_added and
 
1230
         ((af == AF_INET6 and not
 
1231
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1232
                                    &to)->sin6_addr)))
 
1233
          or (af == AF_INET and
 
1234
              /* Not a a IPv4LL address */
 
1235
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1236
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1237
        /* Work around Avahi bug - Avahi does not announce link-local
 
1238
           addresses if it has a global address, so local hosts with
 
1239
           *only* a link-local address (e.g. Mandos clients) cannot
 
1240
           connect to a Mandos server announced by Avahi on a server
 
1241
           host with a global address.  Work around this by retrying
 
1242
           with an explicit route added with the server's address.
 
1243
           
 
1244
           Avahi bug reference:
 
1245
           http://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1246
           https://bugs.debian.org/587961
 
1247
        */
 
1248
        if(debug){
 
1249
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1250
                       " direct route\n");
 
1251
        }
 
1252
        int e = errno;
 
1253
        route_added = add_local_route(ip, if_index);
 
1254
        if(route_added){
 
1255
          continue;
 
1256
        }
 
1257
        errno = e;
 
1258
      }
 
1259
      if(errno != ECONNREFUSED or debug){
 
1260
        int e = errno;
 
1261
        perror_plus("connect");
 
1262
        errno = e;
 
1263
      }
 
1264
      goto mandos_end;
 
1265
    }
 
1266
    
 
1267
    if(quit_now){
 
1268
      errno = EINTR;
 
1269
      goto mandos_end;
 
1270
    }
 
1271
    break;
798
1272
  }
799
1273
  
800
1274
  const char *out = mandos_protocol_version;
802
1276
  while(true){
803
1277
    size_t out_size = strlen(out);
804
1278
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
805
 
                                   out_size - written));
 
1279
                                        out_size - written));
806
1280
    if(ret == -1){
807
1281
      int e = errno;
808
1282
      perror_plus("write");
828
1302
  }
829
1303
  
830
1304
  if(debug){
831
 
    fprintf(stderr, "Mandos plugin mandos-client: "
832
 
            "Establishing TLS session with %s\n", ip);
 
1305
    fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
833
1306
  }
834
1307
  
835
1308
  if(quit_now){
837
1310
    goto mandos_end;
838
1311
  }
839
1312
  
840
 
  /* Spurious warning from -Wint-to-pointer-cast */
841
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
1313
  /* This casting via intptr_t is to eliminate warning about casting
 
1314
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
1315
     function "set-session-transport-fd!" does it. */
 
1316
  gnutls_transport_set_ptr(session,
 
1317
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
842
1318
  
843
1319
  if(quit_now){
844
1320
    errno = EINTR;
855
1331
  
856
1332
  if(ret != GNUTLS_E_SUCCESS){
857
1333
    if(debug){
858
 
      fprintf(stderr, "Mandos plugin mandos-client: "
859
 
              "*** GnuTLS Handshake failed ***\n");
 
1334
      fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
860
1335
      gnutls_perror(ret);
861
1336
    }
862
1337
    errno = EPROTO;
866
1341
  /* Read OpenPGP packet that contains the wanted password */
867
1342
  
868
1343
  if(debug){
869
 
    fprintf(stderr, "Mandos plugin mandos-client: "
870
 
            "Retrieving OpenPGP encrypted password from %s\n", ip);
 
1344
    fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
 
1345
                 " %s\n", ip);
871
1346
  }
872
1347
  
873
1348
  while(true){
878
1353
    }
879
1354
    
880
1355
    buffer_capacity = incbuffer(&buffer, buffer_length,
881
 
                                   buffer_capacity);
 
1356
                                buffer_capacity);
882
1357
    if(buffer_capacity == 0){
883
1358
      int e = errno;
884
1359
      perror_plus("incbuffer");
911
1386
          }
912
1387
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
913
1388
        if(ret < 0){
914
 
          fprintf(stderr, "Mandos plugin mandos-client: "
915
 
                  "*** GnuTLS Re-handshake failed ***\n");
 
1389
          fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
 
1390
                       "***\n");
916
1391
          gnutls_perror(ret);
917
1392
          errno = EPROTO;
918
1393
          goto mandos_end;
919
1394
        }
920
1395
        break;
921
1396
      default:
922
 
        fprintf(stderr, "Mandos plugin mandos-client: "
923
 
                "Unknown error while reading data from"
924
 
                " encrypted session with Mandos server\n");
 
1397
        fprintf_plus(stderr, "Unknown error while reading data from"
 
1398
                     " encrypted session with Mandos server\n");
925
1399
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
926
1400
        errno = EIO;
927
1401
        goto mandos_end;
932
1406
  }
933
1407
  
934
1408
  if(debug){
935
 
    fprintf(stderr, "Mandos plugin mandos-client: "
936
 
            "Closing TLS session\n");
 
1409
    fprintf_plus(stderr, "Closing TLS session\n");
937
1410
  }
938
1411
  
939
1412
  if(quit_now){
951
1424
  
952
1425
  if(buffer_length > 0){
953
1426
    ssize_t decrypted_buffer_size;
954
 
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
955
 
                                               buffer_length,
956
 
                                               &decrypted_buffer);
 
1427
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
 
1428
                                               &decrypted_buffer, mc);
957
1429
    if(decrypted_buffer_size >= 0){
958
1430
      
959
1431
      written = 0;
969
1441
        if(ret == 0 and ferror(stdout)){
970
1442
          int e = errno;
971
1443
          if(debug){
972
 
            fprintf(stderr, "Mandos plugin mandos-client: "
973
 
                    "Error writing encrypted data: %s\n",
974
 
                    strerror(errno));
 
1444
            fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1445
                         strerror(errno));
975
1446
          }
976
1447
          errno = e;
977
1448
          goto mandos_end;
986
1457
  
987
1458
 mandos_end:
988
1459
  {
 
1460
    if(route_added){
 
1461
      if(not delete_local_route(ip, if_index)){
 
1462
        fprintf_plus(stderr, "Failed to delete local route to %s on"
 
1463
                     " interface %d", ip, if_index);
 
1464
      }
 
1465
    }
989
1466
    int e = errno;
990
1467
    free(decrypted_buffer);
991
1468
    free(buffer);
992
1469
    if(tcp_sd >= 0){
993
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1470
      ret = close(tcp_sd);
994
1471
    }
995
1472
    if(ret == -1){
996
1473
      if(e == 0){
1008
1485
  return retval;
1009
1486
}
1010
1487
 
 
1488
__attribute__((nonnull))
1011
1489
static void resolve_callback(AvahiSServiceResolver *r,
1012
1490
                             AvahiIfIndex interface,
1013
1491
                             AvahiProtocol proto,
1021
1499
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
1022
1500
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
1023
1501
                             flags,
1024
 
                             AVAHI_GCC_UNUSED void* userdata){
1025
 
  assert(r);
 
1502
                             void *mc){
 
1503
  if(r == NULL){
 
1504
    return;
 
1505
  }
1026
1506
  
1027
1507
  /* Called whenever a service has been resolved successfully or
1028
1508
     timed out */
1029
1509
  
1030
1510
  if(quit_now){
 
1511
    avahi_s_service_resolver_free(r);
1031
1512
    return;
1032
1513
  }
1033
1514
  
1034
1515
  switch(event){
1035
1516
  default:
1036
1517
  case AVAHI_RESOLVER_FAILURE:
1037
 
    fprintf(stderr, "Mandos plugin mandos-client: "
1038
 
            "(Avahi Resolver) Failed to resolve service '%s'"
1039
 
            " of type '%s' in domain '%s': %s\n", name, type, domain,
1040
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
1518
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
 
1519
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
 
1520
                 domain,
 
1521
                 avahi_strerror(avahi_server_errno
 
1522
                                (((mandos_context*)mc)->server)));
1041
1523
    break;
1042
1524
    
1043
1525
  case AVAHI_RESOLVER_FOUND:
1045
1527
      char ip[AVAHI_ADDRESS_STR_MAX];
1046
1528
      avahi_address_snprint(ip, sizeof(ip), address);
1047
1529
      if(debug){
1048
 
        fprintf(stderr, "Mandos plugin mandos-client: "
1049
 
                "Mandos server \"%s\" found on %s (%s, %"
1050
 
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1051
 
                ip, (intmax_t)interface, port);
 
1530
        fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
1531
                     PRIdMAX ") on port %" PRIu16 "\n", name,
 
1532
                     host_name, ip, (intmax_t)interface, port);
1052
1533
      }
1053
 
      int ret = start_mandos_communication(ip, port, interface,
1054
 
                                           avahi_proto_to_af(proto));
 
1534
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1535
                                           interface,
 
1536
                                           avahi_proto_to_af(proto),
 
1537
                                           mc);
1055
1538
      if(ret == 0){
1056
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1539
        avahi_simple_poll_quit(simple_poll);
1057
1540
      } else {
1058
 
        ret = add_server(ip, port, interface,
1059
 
                         avahi_proto_to_af(proto));
 
1541
        if(not add_server(ip, (in_port_t)port, interface,
 
1542
                          avahi_proto_to_af(proto),
 
1543
                          &((mandos_context*)mc)->current_server)){
 
1544
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1545
                       " list\n", name);
 
1546
        }
1060
1547
      }
1061
1548
    }
1062
1549
  }
1072
1559
                            const char *domain,
1073
1560
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1074
1561
                            flags,
1075
 
                            AVAHI_GCC_UNUSED void* userdata){
1076
 
  assert(b);
 
1562
                            void *mc){
 
1563
  if(b == NULL){
 
1564
    return;
 
1565
  }
1077
1566
  
1078
1567
  /* Called whenever a new services becomes available on the LAN or
1079
1568
     is removed from the LAN */
1086
1575
  default:
1087
1576
  case AVAHI_BROWSER_FAILURE:
1088
1577
    
1089
 
    fprintf(stderr, "Mandos plugin mandos-client: "
1090
 
            "(Avahi browser) %s\n",
1091
 
            avahi_strerror(avahi_server_errno(mc.server)));
1092
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1578
    fprintf_plus(stderr, "(Avahi browser) %s\n",
 
1579
                 avahi_strerror(avahi_server_errno
 
1580
                                (((mandos_context*)mc)->server)));
 
1581
    avahi_simple_poll_quit(simple_poll);
1093
1582
    return;
1094
1583
    
1095
1584
  case AVAHI_BROWSER_NEW:
1098
1587
       the callback function is called the Avahi server will free the
1099
1588
       resolver for us. */
1100
1589
    
1101
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1102
 
                                    name, type, domain, protocol, 0,
1103
 
                                    resolve_callback, NULL) == NULL)
1104
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1105
 
              "Avahi: Failed to resolve service '%s': %s\n",
1106
 
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
1590
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1591
                                    interface, protocol, name, type,
 
1592
                                    domain, protocol, 0,
 
1593
                                    resolve_callback, mc) == NULL)
 
1594
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
 
1595
                   " %s\n", name,
 
1596
                   avahi_strerror(avahi_server_errno
 
1597
                                  (((mandos_context*)mc)->server)));
1107
1598
    break;
1108
1599
    
1109
1600
  case AVAHI_BROWSER_REMOVE:
1112
1603
  case AVAHI_BROWSER_ALL_FOR_NOW:
1113
1604
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
1114
1605
    if(debug){
1115
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1116
 
              "No Mandos server found, still searching...\n");
 
1606
      fprintf_plus(stderr, "No Mandos server found, still"
 
1607
                   " searching...\n");
1117
1608
    }
1118
1609
    break;
1119
1610
  }
1128
1619
  signal_received = sig;
1129
1620
  int old_errno = errno;
1130
1621
  /* set main loop to exit */
1131
 
  if(mc.simple_poll != NULL){
1132
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1622
  if(simple_poll != NULL){
 
1623
    avahi_simple_poll_quit(simple_poll);
1133
1624
  }
1134
1625
  errno = old_errno;
1135
1626
}
1136
1627
 
 
1628
__attribute__((nonnull, warn_unused_result))
1137
1629
bool get_flags(const char *ifname, struct ifreq *ifr){
1138
1630
  int ret;
 
1631
  error_t ret_errno;
1139
1632
  
1140
1633
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1141
1634
  if(s < 0){
 
1635
    ret_errno = errno;
1142
1636
    perror_plus("socket");
 
1637
    errno = ret_errno;
1143
1638
    return false;
1144
1639
  }
1145
1640
  strcpy(ifr->ifr_name, ifname);
1146
1641
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1147
1642
  if(ret == -1){
1148
1643
    if(debug){
 
1644
      ret_errno = errno;
1149
1645
      perror_plus("ioctl SIOCGIFFLAGS");
 
1646
      errno = ret_errno;
1150
1647
    }
1151
1648
    return false;
1152
1649
  }
1153
1650
  return true;
1154
1651
}
1155
1652
 
 
1653
__attribute__((nonnull, warn_unused_result))
1156
1654
bool good_flags(const char *ifname, const struct ifreq *ifr){
1157
1655
  
1158
1656
  /* Reject the loopback device */
1159
1657
  if(ifr->ifr_flags & IFF_LOOPBACK){
1160
1658
    if(debug){
1161
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1162
 
              "Rejecting loopback interface \"%s\"\n", ifname);
 
1659
      fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
 
1660
                   ifname);
1163
1661
    }
1164
1662
    return false;
1165
1663
  }
1166
1664
  /* Accept point-to-point devices only if connect_to is specified */
1167
1665
  if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1168
1666
    if(debug){
1169
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1170
 
              "Accepting point-to-point interface \"%s\"\n", ifname);
 
1667
      fprintf_plus(stderr, "Accepting point-to-point interface"
 
1668
                   " \"%s\"\n", ifname);
1171
1669
    }
1172
1670
    return true;
1173
1671
  }
1174
1672
  /* Otherwise, reject non-broadcast-capable devices */
1175
1673
  if(not (ifr->ifr_flags & IFF_BROADCAST)){
1176
1674
    if(debug){
1177
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1178
 
              "Rejecting non-broadcast interface \"%s\"\n", ifname);
 
1675
      fprintf_plus(stderr, "Rejecting non-broadcast interface"
 
1676
                   " \"%s\"\n", ifname);
1179
1677
    }
1180
1678
    return false;
1181
1679
  }
1182
1680
  /* Reject non-ARP interfaces (including dummy interfaces) */
1183
1681
  if(ifr->ifr_flags & IFF_NOARP){
1184
1682
    if(debug){
1185
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1186
 
              "Rejecting non-ARP interface \"%s\"\n", ifname);
 
1683
      fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
 
1684
                   ifname);
1187
1685
    }
1188
1686
    return false;
1189
1687
  }
1190
1688
  
1191
1689
  /* Accept this device */
1192
1690
  if(debug){
1193
 
    fprintf(stderr, "Mandos plugin mandos-client: "
1194
 
            "Interface \"%s\" is good\n", ifname);
 
1691
    fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1195
1692
  }
1196
1693
  return true;
1197
1694
}
1201
1698
 * corresponds to an acceptable network device.
1202
1699
 * (This function is passed to scandir(3) as a filter function.)
1203
1700
 */
 
1701
__attribute__((nonnull, warn_unused_result))
1204
1702
int good_interface(const struct dirent *if_entry){
1205
1703
  if(if_entry->d_name[0] == '.'){
1206
1704
    return 0;
1209
1707
  struct ifreq ifr;
1210
1708
  if(not get_flags(if_entry->d_name, &ifr)){
1211
1709
    if(debug){
1212
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1213
 
              "Failed to get flags for interface \"%s\"\n",
1214
 
              if_entry->d_name);
1215
 
    }
1216
 
    return 0;
1217
 
  }
1218
 
  
1219
 
  if(not good_flags(if_entry->d_name, &ifr)){
1220
 
    return 0;
1221
 
  }
1222
 
  return 1;
1223
 
}
1224
 
 
1225
 
/* 
1226
 
 * This function determines if a directory entry in /sys/class/net
1227
 
 * corresponds to an acceptable network device which is up.
1228
 
 * (This function is passed to scandir(3) as a filter function.)
1229
 
 */
1230
 
int up_interface(const struct dirent *if_entry){
1231
 
  if(if_entry->d_name[0] == '.'){
1232
 
    return 0;
1233
 
  }
1234
 
  
1235
 
  struct ifreq ifr;
1236
 
  if(not get_flags(if_entry->d_name, &ifr)){
1237
 
    if(debug){
1238
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1239
 
              "Failed to get flags for interface \"%s\"\n",
1240
 
              if_entry->d_name);
1241
 
    }
1242
 
    return 0;
1243
 
  }
1244
 
  
1245
 
  /* Reject down interfaces */
1246
 
  if(not (ifr.ifr_flags & IFF_UP)){
1247
 
    if(debug){
1248
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1249
 
              "Rejecting down interface \"%s\"\n",
1250
 
              if_entry->d_name);
1251
 
    }
1252
 
    return 0;
1253
 
  }
1254
 
  
1255
 
  /* Reject non-running interfaces */
1256
 
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1257
 
    if(debug){
1258
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1259
 
              "Rejecting non-running interface \"%s\"\n",
1260
 
              if_entry->d_name);
1261
 
    }
1262
 
    return 0;
1263
 
  }
1264
 
  
1265
 
  if(not good_flags(if_entry->d_name, &ifr)){
1266
 
    return 0;
1267
 
  }
1268
 
  return 1;
1269
 
}
1270
 
 
 
1710
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1711
                   "\"%s\"\n", if_entry->d_name);
 
1712
    }
 
1713
    return 0;
 
1714
  }
 
1715
  
 
1716
  if(not good_flags(if_entry->d_name, &ifr)){
 
1717
    return 0;
 
1718
  }
 
1719
  return 1;
 
1720
}
 
1721
 
 
1722
/* 
 
1723
 * This function determines if a network interface is up.
 
1724
 */
 
1725
__attribute__((nonnull, warn_unused_result))
 
1726
bool interface_is_up(const char *interface){
 
1727
  struct ifreq ifr;
 
1728
  if(not get_flags(interface, &ifr)){
 
1729
    if(debug){
 
1730
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1731
                   "\"%s\"\n", interface);
 
1732
    }
 
1733
    return false;
 
1734
  }
 
1735
  
 
1736
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1737
}
 
1738
 
 
1739
/* 
 
1740
 * This function determines if a network interface is running
 
1741
 */
 
1742
__attribute__((nonnull, warn_unused_result))
 
1743
bool interface_is_running(const char *interface){
 
1744
  struct ifreq ifr;
 
1745
  if(not get_flags(interface, &ifr)){
 
1746
    if(debug){
 
1747
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1748
                   "\"%s\"\n", interface);
 
1749
    }
 
1750
    return false;
 
1751
  }
 
1752
  
 
1753
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1754
}
 
1755
 
 
1756
__attribute__((nonnull, pure, warn_unused_result))
1271
1757
int notdotentries(const struct dirent *direntry){
1272
1758
  /* Skip "." and ".." */
1273
1759
  if(direntry->d_name[0] == '.'
1280
1766
}
1281
1767
 
1282
1768
/* Is this directory entry a runnable program? */
 
1769
__attribute__((nonnull, warn_unused_result))
1283
1770
int runnable_hook(const struct dirent *direntry){
1284
1771
  int ret;
 
1772
  size_t sret;
1285
1773
  struct stat st;
1286
1774
  
1287
1775
  if((direntry->d_name)[0] == '\0'){
1289
1777
    return 0;
1290
1778
  }
1291
1779
  
1292
 
  /* Save pointer to last character */
1293
 
  char *end = strchr(direntry->d_name, '\0')-1;
1294
 
  
1295
 
  if(*end == '~'){
1296
 
    /* Backup name~ */
1297
 
    return 0;
1298
 
  }
1299
 
  
1300
 
  if(((direntry->d_name)[0] == '#')
1301
 
     and (*end == '#')){
1302
 
    /* Temporary #name# */
1303
 
    return 0;
1304
 
  }
1305
 
  
1306
 
  /* XXX more rules here */
1307
 
  
1308
 
  char *fullname = NULL;
1309
 
  ret = asprintf(&fullname, "%s/%s", hookdir,
1310
 
                 direntry->d_name);
1311
 
  if(ret < 0){
1312
 
    perror_plus("asprintf");
1313
 
    return 0;
1314
 
  }
1315
 
  
1316
 
  ret = stat(fullname, &st);
 
1780
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
1781
                "abcdefghijklmnopqrstuvwxyz"
 
1782
                "0123456789"
 
1783
                "_.-");
 
1784
  if((direntry->d_name)[sret] != '\0'){
 
1785
    /* Contains non-allowed characters */
 
1786
    if(debug){
 
1787
      fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
 
1788
                   direntry->d_name);
 
1789
    }
 
1790
    return 0;
 
1791
  }
 
1792
  
 
1793
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1317
1794
  if(ret == -1){
1318
1795
    if(debug){
1319
 
      perror_plus("Could not stat plugin");
 
1796
      perror_plus("Could not stat hook");
1320
1797
    }
1321
1798
    return 0;
1322
1799
  }
1323
1800
  if(not (S_ISREG(st.st_mode))){
1324
1801
    /* Not a regular file */
 
1802
    if(debug){
 
1803
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
 
1804
                   direntry->d_name);
 
1805
    }
1325
1806
    return 0;
1326
1807
  }
1327
1808
  if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1328
1809
    /* Not executable */
 
1810
    if(debug){
 
1811
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
 
1812
                   direntry->d_name);
 
1813
    }
1329
1814
    return 0;
1330
1815
  }
 
1816
  if(debug){
 
1817
    fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
 
1818
                 direntry->d_name);
 
1819
  }
1331
1820
  return 1;
1332
1821
}
1333
1822
 
1334
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1823
__attribute__((nonnull, warn_unused_result))
 
1824
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
1825
                            mandos_context *mc){
1335
1826
  int ret;
1336
1827
  struct timespec now;
1337
1828
  struct timespec waited_time;
1338
1829
  intmax_t block_time;
1339
1830
  
1340
1831
  while(true){
1341
 
    if(mc.current_server == NULL){
1342
 
      if (debug){
1343
 
        fprintf(stderr, "Mandos plugin mandos-client: "
1344
 
                "Wait until first server is found. No timeout!\n");
 
1832
    if(mc->current_server == NULL){
 
1833
      if(debug){
 
1834
        fprintf_plus(stderr, "Wait until first server is found."
 
1835
                     " No timeout!\n");
1345
1836
      }
1346
1837
      ret = avahi_simple_poll_iterate(s, -1);
1347
1838
    } else {
1348
 
      if (debug){
1349
 
        fprintf(stderr, "Mandos plugin mandos-client: "
1350
 
                "Check current_server if we should run it,"
1351
 
                " or wait\n");
 
1839
      if(debug){
 
1840
        fprintf_plus(stderr, "Check current_server if we should run"
 
1841
                     " it, or wait\n");
1352
1842
      }
1353
1843
      /* the current time */
1354
1844
      ret = clock_gettime(CLOCK_MONOTONIC, &now);
1359
1849
      /* Calculating in ms how long time between now and server
1360
1850
         who we visted longest time ago. Now - last seen.  */
1361
1851
      waited_time.tv_sec = (now.tv_sec
1362
 
                            - mc.current_server->last_seen.tv_sec);
 
1852
                            - mc->current_server->last_seen.tv_sec);
1363
1853
      waited_time.tv_nsec = (now.tv_nsec
1364
 
                             - mc.current_server->last_seen.tv_nsec);
 
1854
                             - mc->current_server->last_seen.tv_nsec);
1365
1855
      /* total time is 10s/10,000ms.
1366
1856
         Converting to s from ms by dividing by 1,000,
1367
1857
         and ns to ms by dividing by 1,000,000. */
1369
1859
                     - ((intmax_t)waited_time.tv_sec * 1000))
1370
1860
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1371
1861
      
1372
 
      if (debug){
1373
 
        fprintf(stderr, "Mandos plugin mandos-client: "
1374
 
                "Blocking for %" PRIdMAX " ms\n", block_time);
 
1862
      if(debug){
 
1863
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
 
1864
                     block_time);
1375
1865
      }
1376
1866
      
1377
1867
      if(block_time <= 0){
1378
 
        ret = start_mandos_communication(mc.current_server->ip,
1379
 
                                         mc.current_server->port,
1380
 
                                         mc.current_server->if_index,
1381
 
                                         mc.current_server->af);
 
1868
        ret = start_mandos_communication(mc->current_server->ip,
 
1869
                                         mc->current_server->port,
 
1870
                                         mc->current_server->if_index,
 
1871
                                         mc->current_server->af, mc);
1382
1872
        if(ret == 0){
1383
 
          avahi_simple_poll_quit(mc.simple_poll);
 
1873
          avahi_simple_poll_quit(s);
1384
1874
          return 0;
1385
1875
        }
1386
1876
        ret = clock_gettime(CLOCK_MONOTONIC,
1387
 
                            &mc.current_server->last_seen);
 
1877
                            &mc->current_server->last_seen);
1388
1878
        if(ret == -1){
1389
1879
          perror_plus("clock_gettime");
1390
1880
          return -1;
1391
1881
        }
1392
 
        mc.current_server = mc.current_server->next;
 
1882
        mc->current_server = mc->current_server->next;
1393
1883
        block_time = 0;         /* Call avahi to find new Mandos
1394
1884
                                   servers, but don't block */
1395
1885
      }
1397
1887
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1398
1888
    }
1399
1889
    if(ret != 0){
1400
 
      if (ret > 0 or errno != EINTR){
 
1890
      if(ret > 0 or errno != EINTR){
1401
1891
        return (ret != 1) ? ret : 0;
1402
1892
      }
1403
1893
    }
1404
1894
  }
1405
1895
}
1406
1896
 
 
1897
__attribute__((nonnull))
 
1898
void run_network_hooks(const char *mode, const char *interface,
 
1899
                       const float delay){
 
1900
  struct dirent **direntries = NULL;
 
1901
  if(hookdir_fd == -1){
 
1902
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
1903
                      | O_CLOEXEC);
 
1904
    if(hookdir_fd == -1){
 
1905
      if(errno == ENOENT){
 
1906
        if(debug){
 
1907
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1908
                       " found\n", hookdir);
 
1909
        }
 
1910
      } else {
 
1911
        perror_plus("open");
 
1912
      }
 
1913
      return;
 
1914
    }
 
1915
  }
 
1916
#ifdef __GLIBC__
 
1917
#if __GLIBC_PREREQ(2, 15)
 
1918
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
1919
                           runnable_hook, alphasort);
 
1920
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1921
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1922
                         alphasort);
 
1923
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1924
#else   /* not __GLIBC__ */
 
1925
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1926
                         alphasort);
 
1927
#endif  /* not __GLIBC__ */
 
1928
  if(numhooks == -1){
 
1929
    perror_plus("scandir");
 
1930
    return;
 
1931
  }
 
1932
  struct dirent *direntry;
 
1933
  int ret;
 
1934
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
1935
  if(devnull == -1){
 
1936
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
1937
    return;
 
1938
  }
 
1939
  for(int i = 0; i < numhooks; i++){
 
1940
    direntry = direntries[i];
 
1941
    if(debug){
 
1942
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1943
                   direntry->d_name);
 
1944
    }
 
1945
    pid_t hook_pid = fork();
 
1946
    if(hook_pid == 0){
 
1947
      /* Child */
 
1948
      /* Raise privileges */
 
1949
      errno = raise_privileges_permanently();
 
1950
      if(errno != 0){
 
1951
        perror_plus("Failed to raise privileges");
 
1952
        _exit(EX_NOPERM);
 
1953
      }
 
1954
      /* Set group */
 
1955
      errno = 0;
 
1956
      ret = setgid(0);
 
1957
      if(ret == -1){
 
1958
        perror_plus("setgid");
 
1959
        _exit(EX_NOPERM);
 
1960
      }
 
1961
      /* Reset supplementary groups */
 
1962
      errno = 0;
 
1963
      ret = setgroups(0, NULL);
 
1964
      if(ret == -1){
 
1965
        perror_plus("setgroups");
 
1966
        _exit(EX_NOPERM);
 
1967
      }
 
1968
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1969
      if(ret == -1){
 
1970
        perror_plus("setenv");
 
1971
        _exit(EX_OSERR);
 
1972
      }
 
1973
      ret = setenv("DEVICE", interface, 1);
 
1974
      if(ret == -1){
 
1975
        perror_plus("setenv");
 
1976
        _exit(EX_OSERR);
 
1977
      }
 
1978
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1979
      if(ret == -1){
 
1980
        perror_plus("setenv");
 
1981
        _exit(EX_OSERR);
 
1982
      }
 
1983
      ret = setenv("MODE", mode, 1);
 
1984
      if(ret == -1){
 
1985
        perror_plus("setenv");
 
1986
        _exit(EX_OSERR);
 
1987
      }
 
1988
      char *delaystring;
 
1989
      ret = asprintf(&delaystring, "%f", (double)delay);
 
1990
      if(ret == -1){
 
1991
        perror_plus("asprintf");
 
1992
        _exit(EX_OSERR);
 
1993
      }
 
1994
      ret = setenv("DELAY", delaystring, 1);
 
1995
      if(ret == -1){
 
1996
        free(delaystring);
 
1997
        perror_plus("setenv");
 
1998
        _exit(EX_OSERR);
 
1999
      }
 
2000
      free(delaystring);
 
2001
      if(connect_to != NULL){
 
2002
        ret = setenv("CONNECT", connect_to, 1);
 
2003
        if(ret == -1){
 
2004
          perror_plus("setenv");
 
2005
          _exit(EX_OSERR);
 
2006
        }
 
2007
      }
 
2008
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2009
                                                   direntry->d_name,
 
2010
                                                   O_RDONLY));
 
2011
      if(hook_fd == -1){
 
2012
        perror_plus("openat");
 
2013
        _exit(EXIT_FAILURE);
 
2014
      }
 
2015
      if(close(hookdir_fd) == -1){
 
2016
        perror_plus("close");
 
2017
        _exit(EXIT_FAILURE);
 
2018
      }
 
2019
      ret = dup2(devnull, STDIN_FILENO);
 
2020
      if(ret == -1){
 
2021
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
2022
        _exit(EX_OSERR);
 
2023
      }
 
2024
      ret = close(devnull);
 
2025
      if(ret == -1){
 
2026
        perror_plus("close");
 
2027
        _exit(EX_OSERR);
 
2028
      }
 
2029
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
2030
      if(ret == -1){
 
2031
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
2032
        _exit(EX_OSERR);
 
2033
      }
 
2034
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
2035
                 environ) == -1){
 
2036
        perror_plus("fexecve");
 
2037
        _exit(EXIT_FAILURE);
 
2038
      }
 
2039
    } else {
 
2040
      if(hook_pid == -1){
 
2041
        perror_plus("fork");
 
2042
        free(direntry);
 
2043
        continue;
 
2044
      }
 
2045
      int status;
 
2046
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
2047
        perror_plus("waitpid");
 
2048
        free(direntry);
 
2049
        continue;
 
2050
      }
 
2051
      if(WIFEXITED(status)){
 
2052
        if(WEXITSTATUS(status) != 0){
 
2053
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
2054
                       " with status %d\n", direntry->d_name,
 
2055
                       WEXITSTATUS(status));
 
2056
          free(direntry);
 
2057
          continue;
 
2058
        }
 
2059
      } else if(WIFSIGNALED(status)){
 
2060
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
2061
                     " signal %d\n", direntry->d_name,
 
2062
                     WTERMSIG(status));
 
2063
        free(direntry);
 
2064
        continue;
 
2065
      } else {
 
2066
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
2067
                     " crashed\n", direntry->d_name);
 
2068
        free(direntry);
 
2069
        continue;
 
2070
      }
 
2071
    }
 
2072
    if(debug){
 
2073
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
2074
                   direntry->d_name);
 
2075
    }
 
2076
    free(direntry);
 
2077
  }
 
2078
  free(direntries);
 
2079
  if(close(hookdir_fd) == -1){
 
2080
    perror_plus("close");
 
2081
  } else {
 
2082
    hookdir_fd = -1;
 
2083
  }
 
2084
  close(devnull);
 
2085
}
 
2086
 
 
2087
__attribute__((nonnull, warn_unused_result))
 
2088
error_t bring_up_interface(const char *const interface,
 
2089
                           const float delay){
 
2090
  error_t old_errno = errno;
 
2091
  int ret;
 
2092
  struct ifreq network;
 
2093
  unsigned int if_index = if_nametoindex(interface);
 
2094
  if(if_index == 0){
 
2095
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
2096
    errno = old_errno;
 
2097
    return ENXIO;
 
2098
  }
 
2099
  
 
2100
  if(quit_now){
 
2101
    errno = old_errno;
 
2102
    return EINTR;
 
2103
  }
 
2104
  
 
2105
  if(not interface_is_up(interface)){
 
2106
    error_t ret_errno = 0, ioctl_errno = 0;
 
2107
    if(not get_flags(interface, &network)){
 
2108
      ret_errno = errno;
 
2109
      fprintf_plus(stderr, "Failed to get flags for interface "
 
2110
                   "\"%s\"\n", interface);
 
2111
      errno = old_errno;
 
2112
      return ret_errno;
 
2113
    }
 
2114
    network.ifr_flags |= IFF_UP; /* set flag */
 
2115
    
 
2116
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2117
    if(sd == -1){
 
2118
      ret_errno = errno;
 
2119
      perror_plus("socket");
 
2120
      errno = old_errno;
 
2121
      return ret_errno;
 
2122
    }
 
2123
    
 
2124
    if(quit_now){
 
2125
      ret = close(sd);
 
2126
      if(ret == -1){
 
2127
        perror_plus("close");
 
2128
      }
 
2129
      errno = old_errno;
 
2130
      return EINTR;
 
2131
    }
 
2132
    
 
2133
    if(debug){
 
2134
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
2135
                   interface);
 
2136
    }
 
2137
    
 
2138
    /* Raise privileges */
 
2139
    ret_errno = raise_privileges();
 
2140
    if(ret_errno != 0){
 
2141
      errno = ret_errno;
 
2142
      perror_plus("Failed to raise privileges");
 
2143
    }
 
2144
    
 
2145
#ifdef __linux__
 
2146
    int ret_linux;
 
2147
    bool restore_loglevel = false;
 
2148
    if(ret_errno == 0){
 
2149
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
2150
         messages about the network interface to mess up the prompt */
 
2151
      ret_linux = klogctl(8, NULL, 5);
 
2152
      if(ret_linux == -1){
 
2153
        perror_plus("klogctl");
 
2154
      } else {
 
2155
        restore_loglevel = true;
 
2156
      }
 
2157
    }
 
2158
#endif  /* __linux__ */
 
2159
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2160
    ioctl_errno = errno;
 
2161
#ifdef __linux__
 
2162
    if(restore_loglevel){
 
2163
      ret_linux = klogctl(7, NULL, 0);
 
2164
      if(ret_linux == -1){
 
2165
        perror_plus("klogctl");
 
2166
      }
 
2167
    }
 
2168
#endif  /* __linux__ */
 
2169
    
 
2170
    /* If raise_privileges() succeeded above */
 
2171
    if(ret_errno == 0){
 
2172
      /* Lower privileges */
 
2173
      ret_errno = lower_privileges();
 
2174
      if(ret_errno != 0){
 
2175
        errno = ret_errno;
 
2176
        perror_plus("Failed to lower privileges");
 
2177
      }
 
2178
    }
 
2179
    
 
2180
    /* Close the socket */
 
2181
    ret = close(sd);
 
2182
    if(ret == -1){
 
2183
      perror_plus("close");
 
2184
    }
 
2185
    
 
2186
    if(ret_setflags == -1){
 
2187
      errno = ioctl_errno;
 
2188
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
2189
      errno = old_errno;
 
2190
      return ioctl_errno;
 
2191
    }
 
2192
  } else if(debug){
 
2193
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
2194
                 interface);
 
2195
  }
 
2196
  
 
2197
  /* Sleep checking until interface is running.
 
2198
     Check every 0.25s, up to total time of delay */
 
2199
  for(int i=0; i < delay * 4; i++){
 
2200
    if(interface_is_running(interface)){
 
2201
      break;
 
2202
    }
 
2203
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
2204
    ret = nanosleep(&sleeptime, NULL);
 
2205
    if(ret == -1 and errno != EINTR){
 
2206
      perror_plus("nanosleep");
 
2207
    }
 
2208
  }
 
2209
  
 
2210
  errno = old_errno;
 
2211
  return 0;
 
2212
}
 
2213
 
 
2214
__attribute__((nonnull, warn_unused_result))
 
2215
error_t take_down_interface(const char *const interface){
 
2216
  error_t old_errno = errno;
 
2217
  struct ifreq network;
 
2218
  unsigned int if_index = if_nametoindex(interface);
 
2219
  if(if_index == 0){
 
2220
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
2221
    errno = old_errno;
 
2222
    return ENXIO;
 
2223
  }
 
2224
  if(interface_is_up(interface)){
 
2225
    error_t ret_errno = 0, ioctl_errno = 0;
 
2226
    if(not get_flags(interface, &network) and debug){
 
2227
      ret_errno = errno;
 
2228
      fprintf_plus(stderr, "Failed to get flags for interface "
 
2229
                   "\"%s\"\n", interface);
 
2230
      errno = old_errno;
 
2231
      return ret_errno;
 
2232
    }
 
2233
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
2234
    
 
2235
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2236
    if(sd == -1){
 
2237
      ret_errno = errno;
 
2238
      perror_plus("socket");
 
2239
      errno = old_errno;
 
2240
      return ret_errno;
 
2241
    }
 
2242
    
 
2243
    if(debug){
 
2244
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
2245
                   interface);
 
2246
    }
 
2247
    
 
2248
    /* Raise privileges */
 
2249
    ret_errno = raise_privileges();
 
2250
    if(ret_errno != 0){
 
2251
      errno = ret_errno;
 
2252
      perror_plus("Failed to raise privileges");
 
2253
    }
 
2254
    
 
2255
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2256
    ioctl_errno = errno;
 
2257
    
 
2258
    /* If raise_privileges() succeeded above */
 
2259
    if(ret_errno == 0){
 
2260
      /* Lower privileges */
 
2261
      ret_errno = lower_privileges();
 
2262
      if(ret_errno != 0){
 
2263
        errno = ret_errno;
 
2264
        perror_plus("Failed to lower privileges");
 
2265
      }
 
2266
    }
 
2267
    
 
2268
    /* Close the socket */
 
2269
    int ret = close(sd);
 
2270
    if(ret == -1){
 
2271
      perror_plus("close");
 
2272
    }
 
2273
    
 
2274
    if(ret_setflags == -1){
 
2275
      errno = ioctl_errno;
 
2276
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
2277
      errno = old_errno;
 
2278
      return ioctl_errno;
 
2279
    }
 
2280
  } else if(debug){
 
2281
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
2282
                 interface);
 
2283
  }
 
2284
  
 
2285
  errno = old_errno;
 
2286
  return 0;
 
2287
}
 
2288
 
1407
2289
int main(int argc, char *argv[]){
 
2290
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2291
                        .priority = "SECURE256:!CTYPE-X.509"
 
2292
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2293
                        .current_server = NULL, .interfaces = NULL,
 
2294
                        .interfaces_size = 0 };
1408
2295
  AvahiSServiceBrowser *sb = NULL;
1409
 
  int error;
 
2296
  error_t ret_errno;
1410
2297
  int ret;
1411
2298
  intmax_t tmpmax;
1412
2299
  char *tmp;
1413
2300
  int exitcode = EXIT_SUCCESS;
1414
 
  const char *interface = "";
1415
 
  struct ifreq network;
1416
 
  int sd = -1;
1417
 
  bool take_down_interface = false;
1418
 
  uid_t uid;
1419
 
  gid_t gid;
1420
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1421
 
  bool tempdir_created = false;
 
2301
  char *interfaces_to_take_down = NULL;
 
2302
  size_t interfaces_to_take_down_size = 0;
 
2303
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2304
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2305
  char *tempdir = NULL;
1422
2306
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1423
2307
  const char *seckey = PATHDIR "/" SECKEY;
1424
2308
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2309
  const char *dh_params_file = NULL;
 
2310
  char *interfaces_hooks = NULL;
1425
2311
  
1426
2312
  bool gnutls_initialized = false;
1427
2313
  bool gpgme_initialized = false;
1479
2365
        .doc = "Bit length of the prime number used in the"
1480
2366
        " Diffie-Hellman key exchange",
1481
2367
        .group = 2 },
 
2368
      { .name = "dh-params", .key = 134,
 
2369
        .arg = "FILE",
 
2370
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
 
2371
        " for the Diffie-Hellman key exchange",
 
2372
        .group = 2 },
1482
2373
      { .name = "priority", .key = 130,
1483
2374
        .arg = "STRING",
1484
2375
        .doc = "GnuTLS priority string for the TLS handshake",
1489
2380
        .group = 2 },
1490
2381
      { .name = "retry", .key = 132,
1491
2382
        .arg = "SECONDS",
1492
 
        .doc = "Retry interval used when denied by the mandos server",
 
2383
        .doc = "Retry interval used when denied by the Mandos server",
1493
2384
        .group = 2 },
1494
2385
      { .name = "network-hook-dir", .key = 133,
1495
2386
        .arg = "DIR",
1518
2409
        connect_to = arg;
1519
2410
        break;
1520
2411
      case 'i':                 /* --interface */
1521
 
        interface = arg;
 
2412
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2413
                                 arg, (int)',');
 
2414
        if(ret_errno != 0){
 
2415
          argp_error(state, "%s", strerror(ret_errno));
 
2416
        }
1522
2417
        break;
1523
2418
      case 's':                 /* --seckey */
1524
2419
        seckey = arg;
1535
2430
        }
1536
2431
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1537
2432
        break;
 
2433
      case 134:                 /* --dh-params */
 
2434
        dh_params_file = arg;
 
2435
        break;
1538
2436
      case 130:                 /* --priority */
1539
2437
        mc.priority = arg;
1540
2438
        break;
1567
2465
        argp_state_help(state, state->out_stream,
1568
2466
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1569
2467
      case 'V':                 /* --version */
1570
 
        fprintf(state->out_stream, "Mandos plugin mandos-client: ");
1571
 
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
2468
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1572
2469
        exit(argp_err_exit_status);
1573
2470
        break;
1574
2471
      default:
1597
2494
      goto end;
1598
2495
    }
1599
2496
  }
1600
 
    
 
2497
  
1601
2498
  {
1602
2499
    /* Work around Debian bug #633582:
1603
2500
       <http://bugs.debian.org/633582> */
1604
 
    struct stat st;
1605
 
    
1606
 
    /* Re-raise priviliges */
1607
 
    errno = 0;
1608
 
    ret = seteuid(0);
1609
 
    if(ret == -1){
1610
 
      perror_plus("seteuid");
1611
 
    }
1612
 
    
1613
 
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1614
 
      int seckey_fd = open(seckey, O_RDONLY);
1615
 
      if(seckey_fd == -1){
1616
 
        perror_plus("open");
1617
 
      } else {
1618
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1619
 
        if(ret == -1){
1620
 
          perror_plus("fstat");
1621
 
        } else {
1622
 
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1623
 
            ret = fchown(seckey_fd, uid, gid);
1624
 
            if(ret == -1){
1625
 
              perror_plus("fchown");
1626
 
            }
1627
 
          }
1628
 
        }
1629
 
        TEMP_FAILURE_RETRY(close(seckey_fd));
1630
 
      }
1631
 
    }
1632
 
    
1633
 
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1634
 
      int pubkey_fd = open(pubkey, O_RDONLY);
1635
 
      if(pubkey_fd == -1){
1636
 
        perror_plus("open");
1637
 
      } else {
1638
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1639
 
        if(ret == -1){
1640
 
          perror_plus("fstat");
1641
 
        } else {
1642
 
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1643
 
            ret = fchown(pubkey_fd, uid, gid);
1644
 
            if(ret == -1){
1645
 
              perror_plus("fchown");
1646
 
            }
1647
 
          }
1648
 
        }
1649
 
        TEMP_FAILURE_RETRY(close(pubkey_fd));
1650
 
      }
1651
 
    }
1652
 
    
1653
 
    /* Lower privileges */
1654
 
    errno = 0;
1655
 
    ret = seteuid(uid);
1656
 
    if(ret == -1){
1657
 
      perror_plus("seteuid");
1658
 
    }
1659
 
  }
1660
 
  
1661
 
  /* Find network hooks and run them */
1662
 
  {
1663
 
    struct dirent **direntries;
1664
 
    struct dirent *direntry;
1665
 
    int numhooks = scandir(hookdir, &direntries, runnable_hook,
1666
 
                           alphasort);
1667
 
    if(numhooks == -1){
1668
 
      perror_plus("scandir");
 
2501
    
 
2502
    /* Re-raise privileges */
 
2503
    ret_errno = raise_privileges();
 
2504
    if(ret_errno != 0){
 
2505
      errno = ret_errno;
 
2506
      perror_plus("Failed to raise privileges");
1669
2507
    } else {
1670
 
      int devnull = open("/dev/null", O_RDONLY);
1671
 
      for(int i = 0; i < numhooks; i++){
1672
 
        direntry = direntries[0];
1673
 
        char *fullname = NULL;
1674
 
        ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1675
 
        if(ret < 0){
1676
 
          perror_plus("asprintf");
1677
 
          continue;
1678
 
        }
1679
 
        pid_t hook_pid = fork();
1680
 
        if(hook_pid == 0){
1681
 
          /* Child */
1682
 
          dup2(devnull, STDIN_FILENO);
1683
 
          close(devnull);
1684
 
          dup2(STDERR_FILENO, STDOUT_FILENO);
1685
 
          ret = setenv("DEVICE", interface, 1);
1686
 
          if(ret == -1){
1687
 
            perror_plus("setenv");
1688
 
            exit(1);
1689
 
          }
1690
 
          ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1691
 
          if(ret == -1){
1692
 
            perror_plus("setenv");
1693
 
            exit(1);
1694
 
          }
1695
 
          ret = setenv("MODE", "start", 1);
1696
 
          if(ret == -1){
1697
 
            perror_plus("setenv");
1698
 
            exit(1);
1699
 
          }
1700
 
          char *delaystring;
1701
 
          ret = asprintf(&delaystring, "%f", delay);
1702
 
          if(ret == -1){
1703
 
            perror_plus("asprintf");
1704
 
            exit(1);
1705
 
          }
1706
 
          ret = setenv("DELAY", delaystring, 1);
1707
 
          if(ret == -1){
1708
 
            free(delaystring);
1709
 
            perror_plus("setenv");
1710
 
            exit(1);
1711
 
          }
1712
 
          free(delaystring);
1713
 
          ret = execl(fullname, direntry->d_name, "start", NULL);
1714
 
          perror_plus("execl");
1715
 
        } else {
1716
 
          int status;
1717
 
          if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1718
 
            perror_plus("waitpid");
1719
 
            free(fullname);
1720
 
            continue;
1721
 
          }
1722
 
          if(WIFEXITED(status)){
1723
 
            if(WEXITSTATUS(status) != 0){
1724
 
              fprintf(stderr, "Mandos plugin mandos-client: "
1725
 
                      "Warning: network hook \"%s\" exited"
1726
 
                      " with status %d\n", direntry->d_name,
1727
 
                      WEXITSTATUS(status));
1728
 
              free(fullname);
1729
 
              continue;
1730
 
            }
1731
 
          } else if(WIFSIGNALED(status)){
1732
 
            fprintf(stderr, "Mandos plugin mandos-client: "
1733
 
                    "Warning: network hook \"%s\" died by"
1734
 
                    " signal %d\n", direntry->d_name,
1735
 
                    WTERMSIG(status));
1736
 
            free(fullname);
1737
 
            continue;
1738
 
          } else {
1739
 
            fprintf(stderr, "Mandos plugin mandos-client: "
1740
 
                    "Warning: network hook \"%s\" crashed\n",
1741
 
                    direntry->d_name);
1742
 
            free(fullname);
1743
 
            continue;
1744
 
          }
1745
 
        }
1746
 
        free(fullname);
1747
 
        if(quit_now){
1748
 
          goto end;
1749
 
        }
1750
 
      }
1751
 
      close(devnull);
1752
 
    }
 
2508
      struct stat st;
 
2509
      
 
2510
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
2511
        int seckey_fd = open(seckey, O_RDONLY);
 
2512
        if(seckey_fd == -1){
 
2513
          perror_plus("open");
 
2514
        } else {
 
2515
          ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
2516
          if(ret == -1){
 
2517
            perror_plus("fstat");
 
2518
          } else {
 
2519
            if(S_ISREG(st.st_mode)
 
2520
               and st.st_uid == 0 and st.st_gid == 0){
 
2521
              ret = fchown(seckey_fd, uid, gid);
 
2522
              if(ret == -1){
 
2523
                perror_plus("fchown");
 
2524
              }
 
2525
            }
 
2526
          }
 
2527
          close(seckey_fd);
 
2528
        }
 
2529
      }
 
2530
      
 
2531
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
2532
        int pubkey_fd = open(pubkey, O_RDONLY);
 
2533
        if(pubkey_fd == -1){
 
2534
          perror_plus("open");
 
2535
        } else {
 
2536
          ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
2537
          if(ret == -1){
 
2538
            perror_plus("fstat");
 
2539
          } else {
 
2540
            if(S_ISREG(st.st_mode)
 
2541
               and st.st_uid == 0 and st.st_gid == 0){
 
2542
              ret = fchown(pubkey_fd, uid, gid);
 
2543
              if(ret == -1){
 
2544
                perror_plus("fchown");
 
2545
              }
 
2546
            }
 
2547
          }
 
2548
          close(pubkey_fd);
 
2549
        }
 
2550
      }
 
2551
      
 
2552
      if(dh_params_file != NULL
 
2553
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2554
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2555
        if(dhparams_fd == -1){
 
2556
          perror_plus("open");
 
2557
        } else {
 
2558
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2559
          if(ret == -1){
 
2560
            perror_plus("fstat");
 
2561
          } else {
 
2562
            if(S_ISREG(st.st_mode)
 
2563
               and st.st_uid == 0 and st.st_gid == 0){
 
2564
              ret = fchown(dhparams_fd, uid, gid);
 
2565
              if(ret == -1){
 
2566
                perror_plus("fchown");
 
2567
              }
 
2568
            }
 
2569
          }
 
2570
          close(dhparams_fd);
 
2571
        }
 
2572
      }
 
2573
      
 
2574
      /* Lower privileges */
 
2575
      ret_errno = lower_privileges();
 
2576
      if(ret_errno != 0){
 
2577
        errno = ret_errno;
 
2578
        perror_plus("Failed to lower privileges");
 
2579
      }
 
2580
    }
 
2581
  }
 
2582
  
 
2583
  /* Remove invalid interface names (except "none") */
 
2584
  {
 
2585
    char *interface = NULL;
 
2586
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2587
                                 interface))){
 
2588
      if(strcmp(interface, "none") != 0
 
2589
         and if_nametoindex(interface) == 0){
 
2590
        if(interface[0] != '\0'){
 
2591
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2592
                       " \"%s\"\n", interface);
 
2593
        }
 
2594
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
 
2595
        interface = NULL;
 
2596
      }
 
2597
    }
 
2598
  }
 
2599
  
 
2600
  /* Run network hooks */
 
2601
  {
 
2602
    if(mc.interfaces != NULL){
 
2603
      interfaces_hooks = malloc(mc.interfaces_size);
 
2604
      if(interfaces_hooks == NULL){
 
2605
        perror_plus("malloc");
 
2606
        goto end;
 
2607
      }
 
2608
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2609
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2610
    }
 
2611
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2612
                      interfaces_hooks : "", delay);
1753
2613
  }
1754
2614
  
1755
2615
  if(not debug){
1756
2616
    avahi_set_log_function(empty_log);
1757
2617
  }
1758
2618
  
1759
 
  if(interface[0] == '\0'){
1760
 
    struct dirent **direntries;
1761
 
    /* First look for interfaces that are up */
1762
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1763
 
                  alphasort);
1764
 
    if(ret == 0){
1765
 
      /* No up interfaces, look for any good interfaces */
1766
 
      free(direntries);
1767
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1768
 
                    alphasort);
1769
 
    }
1770
 
    if(ret >= 1){
1771
 
      /* Pick the first interface returned */
1772
 
      interface = strdup(direntries[0]->d_name);
1773
 
      if(debug){
1774
 
        fprintf(stderr, "Mandos plugin mandos-client: "
1775
 
                "Using interface \"%s\"\n", interface);
1776
 
      }
1777
 
      if(interface == NULL){
1778
 
        perror_plus("malloc");
1779
 
        free(direntries);
1780
 
        exitcode = EXIT_FAILURE;
1781
 
        goto end;
1782
 
      }
1783
 
      free(direntries);
1784
 
    } else {
1785
 
      free(direntries);
1786
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1787
 
              "Could not find a network interface\n");
1788
 
      exitcode = EXIT_FAILURE;
1789
 
      goto end;
1790
 
    }
1791
 
  }
1792
 
  
1793
2619
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1794
2620
     from the signal handler */
1795
2621
  /* Initialize the pseudo-RNG for Avahi */
1796
2622
  srand((unsigned int) time(NULL));
1797
 
  mc.simple_poll = avahi_simple_poll_new();
1798
 
  if(mc.simple_poll == NULL){
1799
 
    fprintf(stderr, "Mandos plugin mandos-client: "
1800
 
            "Avahi: Failed to create simple poll object.\n");
 
2623
  simple_poll = avahi_simple_poll_new();
 
2624
  if(simple_poll == NULL){
 
2625
    fprintf_plus(stderr,
 
2626
                 "Avahi: Failed to create simple poll object.\n");
1801
2627
    exitcode = EX_UNAVAILABLE;
1802
2628
    goto end;
1803
2629
  }
1865
2691
    }
1866
2692
  }
1867
2693
  
1868
 
  /* If the interface is down, bring it up */
1869
 
  if(strcmp(interface, "none") != 0){
1870
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1871
 
    if(if_index == 0){
1872
 
      fprintf(stderr, "Mandos plugin mandos-client: "
1873
 
              "No such interface: \"%s\"\n", interface);
1874
 
      exitcode = EX_UNAVAILABLE;
1875
 
      goto end;
1876
 
    }
1877
 
    
1878
 
    if(quit_now){
1879
 
      goto end;
1880
 
    }
1881
 
    
1882
 
    /* Re-raise priviliges */
1883
 
    errno = 0;
1884
 
    ret = seteuid(0);
1885
 
    if(ret == -1){
1886
 
      perror_plus("seteuid");
1887
 
    }
1888
 
    
1889
 
#ifdef __linux__
1890
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1891
 
       messages about the network interface to mess up the prompt */
1892
 
    ret = klogctl(8, NULL, 5);
1893
 
    bool restore_loglevel = true;
1894
 
    if(ret == -1){
1895
 
      restore_loglevel = false;
1896
 
      perror_plus("klogctl");
1897
 
    }
1898
 
#endif  /* __linux__ */
1899
 
    
1900
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1901
 
    if(sd < 0){
1902
 
      perror_plus("socket");
1903
 
      exitcode = EX_OSERR;
1904
 
#ifdef __linux__
1905
 
      if(restore_loglevel){
1906
 
        ret = klogctl(7, NULL, 0);
1907
 
        if(ret == -1){
1908
 
          perror_plus("klogctl");
1909
 
        }
1910
 
      }
1911
 
#endif  /* __linux__ */
1912
 
      /* Lower privileges */
1913
 
      errno = 0;
1914
 
      ret = seteuid(uid);
1915
 
      if(ret == -1){
1916
 
        perror_plus("seteuid");
1917
 
      }
1918
 
      goto end;
1919
 
    }
1920
 
    strcpy(network.ifr_name, interface);
1921
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1922
 
    if(ret == -1){
1923
 
      perror_plus("ioctl SIOCGIFFLAGS");
1924
 
#ifdef __linux__
1925
 
      if(restore_loglevel){
1926
 
        ret = klogctl(7, NULL, 0);
1927
 
        if(ret == -1){
1928
 
          perror_plus("klogctl");
1929
 
        }
1930
 
      }
1931
 
#endif  /* __linux__ */
1932
 
      exitcode = EX_OSERR;
1933
 
      /* Lower privileges */
1934
 
      errno = 0;
1935
 
      ret = seteuid(uid);
1936
 
      if(ret == -1){
1937
 
        perror_plus("seteuid");
1938
 
      }
1939
 
      goto end;
1940
 
    }
1941
 
    if((network.ifr_flags & IFF_UP) == 0){
1942
 
      network.ifr_flags |= IFF_UP;
1943
 
      take_down_interface = true;
1944
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1945
 
      if(ret == -1){
1946
 
        take_down_interface = false;
1947
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1948
 
        exitcode = EX_OSERR;
1949
 
#ifdef __linux__
1950
 
        if(restore_loglevel){
1951
 
          ret = klogctl(7, NULL, 0);
1952
 
          if(ret == -1){
1953
 
            perror_plus("klogctl");
 
2694
  /* If no interfaces were specified, make a list */
 
2695
  if(mc.interfaces == NULL){
 
2696
    struct dirent **direntries = NULL;
 
2697
    /* Look for any good interfaces */
 
2698
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2699
                  alphasort);
 
2700
    if(ret >= 1){
 
2701
      /* Add all found interfaces to interfaces list */
 
2702
      for(int i = 0; i < ret; ++i){
 
2703
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2704
                             direntries[i]->d_name);
 
2705
        if(ret_errno != 0){
 
2706
          errno = ret_errno;
 
2707
          perror_plus("argz_add");
 
2708
          free(direntries[i]);
 
2709
          continue;
 
2710
        }
 
2711
        if(debug){
 
2712
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2713
                       direntries[i]->d_name);
 
2714
        }
 
2715
        free(direntries[i]);
 
2716
      }
 
2717
      free(direntries);
 
2718
    } else {
 
2719
      if(ret == 0){
 
2720
        free(direntries);
 
2721
      }
 
2722
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2723
      exitcode = EXIT_FAILURE;
 
2724
      goto end;
 
2725
    }
 
2726
  }
 
2727
  
 
2728
  /* Bring up interfaces which are down, and remove any "none"s */
 
2729
  {
 
2730
    char *interface = NULL;
 
2731
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2732
                                 interface))){
 
2733
      /* If interface name is "none", stop bringing up interfaces.
 
2734
         Also remove all instances of "none" from the list */
 
2735
      if(strcmp(interface, "none") == 0){
 
2736
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2737
                    interface);
 
2738
        interface = NULL;
 
2739
        while((interface = argz_next(mc.interfaces,
 
2740
                                     mc.interfaces_size, interface))){
 
2741
          if(strcmp(interface, "none") == 0){
 
2742
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2743
                        interface);
 
2744
            interface = NULL;
1954
2745
          }
1955
2746
        }
1956
 
#endif  /* __linux__ */
1957
 
        /* Lower privileges */
1958
 
        errno = 0;
1959
 
        ret = seteuid(uid);
1960
 
        if(ret == -1){
1961
 
          perror_plus("seteuid");
1962
 
        }
1963
 
        goto end;
1964
 
      }
1965
 
    }
1966
 
    /* Sleep checking until interface is running.
1967
 
       Check every 0.25s, up to total time of delay */
1968
 
    for(int i=0; i < delay * 4; i++){
1969
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1970
 
      if(ret == -1){
1971
 
        perror_plus("ioctl SIOCGIFFLAGS");
1972
 
      } else if(network.ifr_flags & IFF_RUNNING){
1973
2747
        break;
1974
2748
      }
1975
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1976
 
      ret = nanosleep(&sleeptime, NULL);
1977
 
      if(ret == -1 and errno != EINTR){
1978
 
        perror_plus("nanosleep");
1979
 
      }
1980
 
    }
1981
 
    if(not take_down_interface){
1982
 
      /* We won't need the socket anymore */
1983
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1984
 
      if(ret == -1){
1985
 
        perror_plus("close");
1986
 
      }
1987
 
    }
1988
 
#ifdef __linux__
1989
 
    if(restore_loglevel){
1990
 
      /* Restores kernel loglevel to default */
1991
 
      ret = klogctl(7, NULL, 0);
1992
 
      if(ret == -1){
1993
 
        perror_plus("klogctl");
1994
 
      }
1995
 
    }
1996
 
#endif  /* __linux__ */
1997
 
    /* Lower privileges */
1998
 
    errno = 0;
1999
 
    if(take_down_interface){
2000
 
      /* Lower privileges */
2001
 
      ret = seteuid(uid);
2002
 
      if(ret == -1){
2003
 
        perror_plus("seteuid");
2004
 
      }
2005
 
    } else {
2006
 
      /* Lower privileges permanently */
2007
 
      ret = setuid(uid);
2008
 
      if(ret == -1){
2009
 
        perror_plus("setuid");
2010
 
      }
2011
 
    }
 
2749
      bool interface_was_up = interface_is_up(interface);
 
2750
      errno = bring_up_interface(interface, delay);
 
2751
      if(not interface_was_up){
 
2752
        if(errno != 0){
 
2753
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2754
                       " %s\n", interface, strerror(errno));
 
2755
        } else {
 
2756
          errno = argz_add(&interfaces_to_take_down,
 
2757
                           &interfaces_to_take_down_size,
 
2758
                           interface);
 
2759
          if(errno != 0){
 
2760
            perror_plus("argz_add");
 
2761
          }
 
2762
        }
 
2763
      }
 
2764
    }
 
2765
    if(debug and (interfaces_to_take_down == NULL)){
 
2766
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2767
    }
 
2768
  }
 
2769
  
 
2770
  /* If we only got one interface, explicitly use only that one */
 
2771
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2772
    if(debug){
 
2773
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2774
                   mc.interfaces);
 
2775
    }
 
2776
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2012
2777
  }
2013
2778
  
2014
2779
  if(quit_now){
2015
2780
    goto end;
2016
2781
  }
2017
2782
  
2018
 
  ret = init_gnutls_global(pubkey, seckey);
 
2783
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2019
2784
  if(ret == -1){
2020
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2021
 
            "init_gnutls_global failed\n");
 
2785
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2022
2786
    exitcode = EX_UNAVAILABLE;
2023
2787
    goto end;
2024
2788
  } else {
2029
2793
    goto end;
2030
2794
  }
2031
2795
  
2032
 
  if(mkdtemp(tempdir) == NULL){
 
2796
  /* Try /run/tmp before /tmp */
 
2797
  tempdir = mkdtemp(run_tempdir);
 
2798
  if(tempdir == NULL and errno == ENOENT){
 
2799
      if(debug){
 
2800
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
2801
                     run_tempdir, old_tempdir);
 
2802
      }
 
2803
      tempdir = mkdtemp(old_tempdir);
 
2804
  }
 
2805
  if(tempdir == NULL){
2033
2806
    perror_plus("mkdtemp");
2034
2807
    goto end;
2035
2808
  }
2036
 
  tempdir_created = true;
2037
2809
  
2038
2810
  if(quit_now){
2039
2811
    goto end;
2040
2812
  }
2041
2813
  
2042
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
2043
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2044
 
            "init_gpgme failed\n");
 
2814
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
 
2815
    fprintf_plus(stderr, "init_gpgme failed\n");
2045
2816
    exitcode = EX_UNAVAILABLE;
2046
2817
    goto end;
2047
2818
  } else {
2056
2827
    /* Connect directly, do not use Zeroconf */
2057
2828
    /* (Mainly meant for debugging) */
2058
2829
    char *address = strrchr(connect_to, ':');
 
2830
    
2059
2831
    if(address == NULL){
2060
 
      fprintf(stderr, "Mandos plugin mandos-client: "
2061
 
              "No colon in address\n");
 
2832
      fprintf_plus(stderr, "No colon in address\n");
2062
2833
      exitcode = EX_USAGE;
2063
2834
      goto end;
2064
2835
    }
2067
2838
      goto end;
2068
2839
    }
2069
2840
    
2070
 
    uint16_t port;
 
2841
    in_port_t port;
2071
2842
    errno = 0;
2072
2843
    tmpmax = strtoimax(address+1, &tmp, 10);
2073
2844
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
2074
 
       or tmpmax != (uint16_t)tmpmax){
2075
 
      fprintf(stderr, "Mandos plugin mandos-client: "
2076
 
              "Bad port number\n");
 
2845
       or tmpmax != (in_port_t)tmpmax){
 
2846
      fprintf_plus(stderr, "Bad port number\n");
2077
2847
      exitcode = EX_USAGE;
2078
2848
      goto end;
2079
2849
    }
2080
 
  
 
2850
    
2081
2851
    if(quit_now){
2082
2852
      goto end;
2083
2853
    }
2084
2854
    
2085
 
    port = (uint16_t)tmpmax;
 
2855
    port = (in_port_t)tmpmax;
2086
2856
    *address = '\0';
2087
2857
    /* Colon in address indicates IPv6 */
2088
2858
    int af;
2104
2874
    }
2105
2875
    
2106
2876
    while(not quit_now){
2107
 
      ret = start_mandos_communication(address, port, if_index, af);
 
2877
      ret = start_mandos_communication(address, port, if_index, af,
 
2878
                                       &mc);
2108
2879
      if(quit_now or ret == 0){
2109
2880
        break;
2110
2881
      }
2111
2882
      if(debug){
2112
 
        fprintf(stderr, "Mandos plugin mandos-client: "
2113
 
                "Retrying in %d seconds\n", (int)retry_interval);
 
2883
        fprintf_plus(stderr, "Retrying in %d seconds\n",
 
2884
                     (int)retry_interval);
2114
2885
      }
2115
 
      sleep((int)retry_interval);
 
2886
      sleep((unsigned int)retry_interval);
2116
2887
    }
2117
2888
    
2118
 
    if (not quit_now){
 
2889
    if(not quit_now){
2119
2890
      exitcode = EXIT_SUCCESS;
2120
2891
    }
2121
2892
    
2136
2907
    config.publish_domain = 0;
2137
2908
    
2138
2909
    /* Allocate a new server */
2139
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2140
 
                                 (mc.simple_poll), &config, NULL,
2141
 
                                 NULL, &error);
 
2910
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
2911
                                 &config, NULL, NULL, &ret_errno);
2142
2912
    
2143
2913
    /* Free the Avahi configuration data */
2144
2914
    avahi_server_config_free(&config);
2146
2916
  
2147
2917
  /* Check if creating the Avahi server object succeeded */
2148
2918
  if(mc.server == NULL){
2149
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2150
 
            "Failed to create Avahi server: %s\n",
2151
 
            avahi_strerror(error));
 
2919
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
 
2920
                 avahi_strerror(ret_errno));
2152
2921
    exitcode = EX_UNAVAILABLE;
2153
2922
    goto end;
2154
2923
  }
2160
2929
  /* Create the Avahi service browser */
2161
2930
  sb = avahi_s_service_browser_new(mc.server, if_index,
2162
2931
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2163
 
                                   NULL, 0, browse_callback, NULL);
 
2932
                                   NULL, 0, browse_callback,
 
2933
                                   (void *)&mc);
2164
2934
  if(sb == NULL){
2165
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2166
 
            "Failed to create service browser: %s\n",
2167
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
2935
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
 
2936
                 avahi_strerror(avahi_server_errno(mc.server)));
2168
2937
    exitcode = EX_UNAVAILABLE;
2169
2938
    goto end;
2170
2939
  }
2176
2945
  /* Run the main loop */
2177
2946
  
2178
2947
  if(debug){
2179
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2180
 
            "Starting Avahi loop search\n");
 
2948
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2181
2949
  }
2182
 
 
2183
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2184
 
                                (int)(retry_interval * 1000));
 
2950
  
 
2951
  ret = avahi_loop_with_timeout(simple_poll,
 
2952
                                (int)(retry_interval * 1000), &mc);
2185
2953
  if(debug){
2186
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2187
 
            "avahi_loop_with_timeout exited %s\n",
2188
 
            (ret == 0) ? "successfully" : "with error");
 
2954
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
 
2955
                 (ret == 0) ? "successfully" : "with error");
2189
2956
  }
2190
2957
  
2191
2958
 end:
2192
2959
  
2193
2960
  if(debug){
2194
 
    fprintf(stderr, "Mandos plugin mandos-client: "
2195
 
            "%s exiting\n", argv[0]);
 
2961
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
2196
2962
  }
2197
2963
  
2198
2964
  /* Cleanup things */
 
2965
  free(mc.interfaces);
 
2966
  
2199
2967
  if(sb != NULL)
2200
2968
    avahi_s_service_browser_free(sb);
2201
2969
  
2202
2970
  if(mc.server != NULL)
2203
2971
    avahi_server_free(mc.server);
2204
2972
  
2205
 
  if(mc.simple_poll != NULL)
2206
 
    avahi_simple_poll_free(mc.simple_poll);
 
2973
  if(simple_poll != NULL)
 
2974
    avahi_simple_poll_free(simple_poll);
2207
2975
  
2208
2976
  if(gnutls_initialized){
2209
2977
    gnutls_certificate_free_credentials(mc.cred);
2214
2982
  if(gpgme_initialized){
2215
2983
    gpgme_release(mc.ctx);
2216
2984
  }
2217
 
 
 
2985
  
2218
2986
  /* Cleans up the circular linked list of Mandos servers the client
2219
2987
     has seen */
2220
2988
  if(mc.current_server != NULL){
2221
2989
    mc.current_server->prev->next = NULL;
2222
2990
    while(mc.current_server != NULL){
2223
2991
      server *next = mc.current_server->next;
 
2992
#ifdef __GNUC__
 
2993
#pragma GCC diagnostic push
 
2994
#pragma GCC diagnostic ignored "-Wcast-qual"
 
2995
#endif
 
2996
      free((char *)(mc.current_server->ip));
 
2997
#ifdef __GNUC__
 
2998
#pragma GCC diagnostic pop
 
2999
#endif
2224
3000
      free(mc.current_server);
2225
3001
      mc.current_server = next;
2226
3002
    }
2227
3003
  }
2228
3004
  
2229
 
  /* XXX run network hooks "stop" here  */
2230
 
  
2231
 
  /* Take down the network interface */
2232
 
  if(take_down_interface){
2233
 
    /* Re-raise priviliges */
2234
 
    errno = 0;
2235
 
    ret = seteuid(0);
2236
 
    if(ret == -1){
2237
 
      perror_plus("seteuid");
 
3005
  /* Re-raise privileges */
 
3006
  {
 
3007
    ret_errno = raise_privileges();
 
3008
    if(ret_errno != 0){
 
3009
      errno = ret_errno;
 
3010
      perror_plus("Failed to raise privileges");
 
3011
    } else {
 
3012
      
 
3013
      /* Run network hooks */
 
3014
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
3015
                        interfaces_hooks : "", delay);
 
3016
      
 
3017
      /* Take down the network interfaces which were brought up */
 
3018
      {
 
3019
        char *interface = NULL;
 
3020
        while((interface=argz_next(interfaces_to_take_down,
 
3021
                                   interfaces_to_take_down_size,
 
3022
                                   interface))){
 
3023
          ret_errno = take_down_interface(interface);
 
3024
          if(ret_errno != 0){
 
3025
            errno = ret_errno;
 
3026
            perror_plus("Failed to take down interface");
 
3027
          }
 
3028
        }
 
3029
        if(debug and (interfaces_to_take_down == NULL)){
 
3030
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
3031
                       " down\n");
 
3032
        }
 
3033
      }
2238
3034
    }
2239
 
    if(geteuid() == 0){
2240
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2241
 
      if(ret == -1){
2242
 
        perror_plus("ioctl SIOCGIFFLAGS");
2243
 
      } else if(network.ifr_flags & IFF_UP){
2244
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2245
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2246
 
        if(ret == -1){
2247
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2248
 
        }
2249
 
      }
2250
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2251
 
      if(ret == -1){
2252
 
        perror_plus("close");
2253
 
      }
2254
 
      /* Lower privileges permanently */
2255
 
      errno = 0;
2256
 
      ret = setuid(uid);
2257
 
      if(ret == -1){
2258
 
        perror_plus("setuid");
2259
 
      }
 
3035
    
 
3036
    ret_errno = lower_privileges_permanently();
 
3037
    if(ret_errno != 0){
 
3038
      errno = ret_errno;
 
3039
      perror_plus("Failed to lower privileges permanently");
2260
3040
    }
2261
3041
  }
2262
3042
  
 
3043
  free(interfaces_to_take_down);
 
3044
  free(interfaces_hooks);
 
3045
  
2263
3046
  /* Removes the GPGME temp directory and all files inside */
2264
 
  if(tempdir_created){
 
3047
  if(tempdir != NULL){
2265
3048
    struct dirent **direntries = NULL;
2266
 
    struct dirent *direntry = NULL;
2267
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2268
 
                             alphasort);
2269
 
    if (numentries > 0){
2270
 
      for(int i = 0; i < numentries; i++){
2271
 
        direntry = direntries[i];
2272
 
        char *fullname = NULL;
2273
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2274
 
                       direntry->d_name);
2275
 
        if(ret < 0){
2276
 
          perror_plus("asprintf");
2277
 
          continue;
2278
 
        }
2279
 
        ret = remove(fullname);
2280
 
        if(ret == -1){
2281
 
          fprintf(stderr, "Mandos plugin mandos-client: "
2282
 
                  "remove(\"%s\"): %s\n", fullname, strerror(errno));
2283
 
        }
2284
 
        free(fullname);
 
3049
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY
 
3050
                                                  | O_NOFOLLOW
 
3051
                                                  | O_DIRECTORY
 
3052
                                                  | O_PATH));
 
3053
    if(tempdir_fd == -1){
 
3054
      perror_plus("open");
 
3055
    } else {
 
3056
#ifdef __GLIBC__
 
3057
#if __GLIBC_PREREQ(2, 15)
 
3058
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
3059
                                 notdotentries, alphasort);
 
3060
#else  /* not __GLIBC_PREREQ(2, 15) */
 
3061
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
3062
                               alphasort);
 
3063
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
3064
#else   /* not __GLIBC__ */
 
3065
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
3066
                               alphasort);
 
3067
#endif  /* not __GLIBC__ */
 
3068
      if(numentries >= 0){
 
3069
        for(int i = 0; i < numentries; i++){
 
3070
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
3071
          if(ret == -1){
 
3072
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
3073
                         " \"%s\", 0): %s\n", tempdir,
 
3074
                         direntries[i]->d_name, strerror(errno));
 
3075
          }
 
3076
          free(direntries[i]);
 
3077
        }
 
3078
        
 
3079
        /* need to clean even if 0 because man page doesn't specify */
 
3080
        free(direntries);
 
3081
        if(numentries == -1){
 
3082
          perror_plus("scandir");
 
3083
        }
 
3084
        ret = rmdir(tempdir);
 
3085
        if(ret == -1 and errno != ENOENT){
 
3086
          perror_plus("rmdir");
 
3087
        }
2285
3088
      }
2286
 
    }
2287
 
 
2288
 
    /* need to clean even if 0 because man page doesn't specify */
2289
 
    free(direntries);
2290
 
    if (numentries == -1){
2291
 
      perror_plus("scandir");
2292
 
    }
2293
 
    ret = rmdir(tempdir);
2294
 
    if(ret == -1 and errno != ENOENT){
2295
 
      perror_plus("rmdir");
 
3089
      close(tempdir_fd);
2296
3090
    }
2297
3091
  }
2298
3092