/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2019-08-05 21:14:05 UTC
  • Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions

There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version.  We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general.  We prefer the code being there, for the sake of the users.

* debian/mandos-client.lintian-overrides
  (maintainer-script-supports-ancient-package-version): New.
  debian/mandos.lintian-overrides
  (maintainer-script-supports-ancient-package-version): - '' -

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
14
 
 * 
15
 
 * This program is free software: you can redistribute it and/or
16
 
 * modify it under the terms of the GNU General Public License as
17
 
 * published by the Free Software Foundation, either version 3 of the
18
 
 * License, or (at your option) any later version.
19
 
 * 
20
 
 * This program is distributed in the hope that it will be useful, but
 
12
 * Copyright © 2008-2019 Teddy Hogeborn
 
13
 * Copyright © 2008-2019 Björn Påhlsson
 
14
 * 
 
15
 * This file is part of Mandos.
 
16
 * 
 
17
 * Mandos is free software: you can redistribute it and/or modify it
 
18
 * under the terms of the GNU General Public License as published by
 
19
 * the Free Software Foundation, either version 3 of the License, or
 
20
 * (at your option) any later version.
 
21
 * 
 
22
 * Mandos is distributed in the hope that it will be useful, but
21
23
 * WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
25
 * General Public License for more details.
24
26
 * 
25
27
 * You should have received a copy of the GNU General Public License
26
 
 * along with this program.  If not, see
27
 
 * <http://www.gnu.org/licenses/>.
 
28
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
28
29
 * 
29
30
 * Contact the authors at <mandos@recompile.se>.
30
31
 */
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
 
#endif
 
36
#endif  /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
 
#endif
 
39
#endif  /* not _FILE_OFFSET_BITS */
39
40
 
40
41
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
 
42
43
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
 
44
                                   stdout, ferror() */
 
45
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
48
                                   strtof(), abort() */
48
49
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
 
50
#include <string.h>             /* strcmp(), strlen(), strerror(),
 
51
                                   asprintf(), strncpy(), strsignal()
 
52
                                */
51
53
#include <sys/ioctl.h>          /* ioctl */
52
54
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
55
                                   sockaddr_in6, PF_INET6,
55
57
                                   opendir(), DIR */
56
58
#include <sys/stat.h>           /* open(), S_ISREG */
57
59
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
 
60
                                   inet_pton(), connect(),
 
61
                                   getnameinfo() */
 
62
#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
64
                                 */
62
65
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
63
66
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
 
#include <errno.h>              /* perror(), errno,
 
67
#include <errno.h>              /* perror(), errno, EINTR, EINVAL,
 
68
                                   EAI_SYSTEM, ENETUNREACH,
 
69
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
 
70
                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
 
71
                                   ENOTEMPTY,
66
72
                                   program_invocation_short_name */
67
73
#include <time.h>               /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
                                */
74
80
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
81
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause(), _exit() */
77
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
82
                                   setgid(), pause(), _exit(),
 
83
                                   unlinkat() */
 
84
#include <arpa/inet.h>          /* inet_pton(), htons() */
78
85
#include <iso646.h>             /* not, or, and */
79
86
#include <argp.h>               /* struct argp_option, error_t, struct
80
87
                                   argp_state, struct argp,
87
94
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
95
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
89
96
                                   WEXITSTATUS(), WTERMSIG() */
 
97
#include <grp.h>                /* setgroups() */
 
98
#include <argz.h>               /* argz_add_sep(), argz_next(),
 
99
                                   argz_delete(), argz_append(),
 
100
                                   argz_stringify(), argz_add(),
 
101
                                   argz_count() */
 
102
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
103
                                   EAI_SYSTEM, gai_strerror() */
90
104
 
91
105
#ifdef __linux__
92
106
#include <sys/klog.h>           /* klogctl() */
109
123
                                   gnutls_*
110
124
                                   init_gnutls_session(),
111
125
                                   GNUTLS_* */
 
126
#if GNUTLS_VERSION_NUMBER < 0x030600
112
127
#include <gnutls/openpgp.h>
113
128
                         /* gnutls_certificate_set_openpgp_key_file(),
114
129
                            GNUTLS_OPENPGP_FMT_BASE64 */
 
130
#elif GNUTLS_VERSION_NUMBER >= 0x030606
 
131
#include <gnutls/x509.h>        /* gnutls_pkcs_encrypt_flags_t,
 
132
                                 GNUTLS_PKCS_PLAIN,
 
133
                                 GNUTLS_PKCS_NULL_PASSWORD */
 
134
#endif
115
135
 
116
136
/* GPGME */
117
137
#include <gpgme.h>              /* All GPGME types, constants and
125
145
#define PATHDIR "/conf/conf.d/mandos"
126
146
#define SECKEY "seckey.txt"
127
147
#define PUBKEY "pubkey.txt"
 
148
#define TLS_PRIVKEY "tls-privkey.pem"
 
149
#define TLS_PUBKEY "tls-pubkey.pem"
128
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
129
151
 
130
152
bool debug = false;
134
156
static const char sys_class_net[] = "/sys/class/net";
135
157
char *connect_to = NULL;
136
158
const char *hookdir = HOOKDIR;
 
159
int hookdir_fd = -1;
 
160
uid_t uid = 65534;
 
161
gid_t gid = 65534;
137
162
 
138
163
/* Doubly linked list that need to be circularly linked when used */
139
164
typedef struct server{
140
165
  const char *ip;
141
 
  uint16_t port;
 
166
  in_port_t port;
142
167
  AvahiIfIndex if_index;
143
168
  int af;
144
169
  struct timespec last_seen;
148
173
 
149
174
/* Used for passing in values through the Avahi callback functions */
150
175
typedef struct {
151
 
  AvahiSimplePoll *simple_poll;
152
176
  AvahiServer *server;
153
177
  gnutls_certificate_credentials_t cred;
154
178
  unsigned int dh_bits;
156
180
  const char *priority;
157
181
  gpgme_ctx_t ctx;
158
182
  server *current_server;
 
183
  char *interfaces;
 
184
  size_t interfaces_size;
159
185
} mandos_context;
160
186
 
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 };
 
187
/* global so signal handler can reach it*/
 
188
AvahiSimplePoll *simple_poll;
166
189
 
167
190
sig_atomic_t quit_now = 0;
168
191
int signal_received = 0;
169
192
 
170
193
/* Function to use when printing errors */
171
194
void perror_plus(const char *print_text){
 
195
  int e = errno;
172
196
  fprintf(stderr, "Mandos plugin %s: ",
173
197
          program_invocation_short_name);
 
198
  errno = e;
174
199
  perror(print_text);
175
200
}
176
201
 
 
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
177
203
int fprintf_plus(FILE *stream, const char *format, ...){
178
204
  va_list ap;
179
205
  va_start (ap, format);
180
206
  
181
207
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
182
208
                             program_invocation_short_name));
183
 
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
209
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
184
210
}
185
211
 
186
212
/*
188
214
 * bytes. "buffer_capacity" is how much is currently allocated,
189
215
 * "buffer_length" is how much is already used.
190
216
 */
 
217
__attribute__((nonnull, warn_unused_result))
191
218
size_t incbuffer(char **buffer, size_t buffer_length,
192
219
                 size_t buffer_capacity){
193
220
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
194
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
195
 
    if(buffer == NULL){
 
221
    char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
222
    if(new_buf == NULL){
 
223
      int old_errno = errno;
 
224
      free(*buffer);
 
225
      errno = old_errno;
 
226
      *buffer = NULL;
196
227
      return 0;
197
228
    }
 
229
    *buffer = new_buf;
198
230
    buffer_capacity += BUFFER_SIZE;
199
231
  }
200
232
  return buffer_capacity;
201
233
}
202
234
 
203
235
/* Add server to set of servers to retry periodically */
204
 
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
205
 
               int af){
 
236
__attribute__((nonnull, warn_unused_result))
 
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
238
                int af, server **current_server){
206
239
  int ret;
207
240
  server *new_server = malloc(sizeof(server));
208
241
  if(new_server == NULL){
209
242
    perror_plus("malloc");
210
 
    return -1;
 
243
    return false;
211
244
  }
212
245
  *new_server = (server){ .ip = strdup(ip),
213
246
                          .port = port,
215
248
                          .af = af };
216
249
  if(new_server->ip == NULL){
217
250
    perror_plus("strdup");
218
 
    return -1;
 
251
    free(new_server);
 
252
    return false;
 
253
  }
 
254
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
 
255
  if(ret == -1){
 
256
    perror_plus("clock_gettime");
 
257
#ifdef __GNUC__
 
258
#pragma GCC diagnostic push
 
259
#pragma GCC diagnostic ignored "-Wcast-qual"
 
260
#endif
 
261
    free((char *)(new_server->ip));
 
262
#ifdef __GNUC__
 
263
#pragma GCC diagnostic pop
 
264
#endif
 
265
    free(new_server);
 
266
    return false;
219
267
  }
220
268
  /* Special case of first server */
221
 
  if (mc.current_server == NULL){
 
269
  if(*current_server == NULL){
222
270
    new_server->next = new_server;
223
271
    new_server->prev = new_server;
224
 
    mc.current_server = new_server;
225
 
  /* Place the new server last in the list */
 
272
    *current_server = new_server;
226
273
  } else {
227
 
    new_server->next = mc.current_server;
228
 
    new_server->prev = mc.current_server->prev;
 
274
    /* Place the new server last in the list */
 
275
    new_server->next = *current_server;
 
276
    new_server->prev = (*current_server)->prev;
229
277
    new_server->prev->next = new_server;
230
 
    mc.current_server->prev = new_server;
231
 
  }
232
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
233
 
  if(ret == -1){
234
 
    perror_plus("clock_gettime");
235
 
    return -1;
236
 
  }
237
 
  return 0;
 
278
    (*current_server)->prev = new_server;
 
279
  }
 
280
  return true;
 
281
}
 
282
 
 
283
/* Set effective uid to 0, return errno */
 
284
__attribute__((warn_unused_result))
 
285
int raise_privileges(void){
 
286
  int old_errno = errno;
 
287
  int ret = 0;
 
288
  if(seteuid(0) == -1){
 
289
    ret = errno;
 
290
  }
 
291
  errno = old_errno;
 
292
  return ret;
 
293
}
 
294
 
 
295
/* Set effective and real user ID to 0.  Return errno. */
 
296
__attribute__((warn_unused_result))
 
297
int raise_privileges_permanently(void){
 
298
  int old_errno = errno;
 
299
  int ret = raise_privileges();
 
300
  if(ret != 0){
 
301
    errno = old_errno;
 
302
    return ret;
 
303
  }
 
304
  if(setuid(0) == -1){
 
305
    ret = errno;
 
306
  }
 
307
  errno = old_errno;
 
308
  return ret;
 
309
}
 
310
 
 
311
/* Set effective user ID to unprivileged saved user ID */
 
312
__attribute__((warn_unused_result))
 
313
int lower_privileges(void){
 
314
  int old_errno = errno;
 
315
  int ret = 0;
 
316
  if(seteuid(uid) == -1){
 
317
    ret = errno;
 
318
  }
 
319
  errno = old_errno;
 
320
  return ret;
 
321
}
 
322
 
 
323
/* Lower privileges permanently */
 
324
__attribute__((warn_unused_result))
 
325
int lower_privileges_permanently(void){
 
326
  int old_errno = errno;
 
327
  int ret = 0;
 
328
  if(setuid(uid) == -1){
 
329
    ret = errno;
 
330
  }
 
331
  errno = old_errno;
 
332
  return ret;
238
333
}
239
334
 
240
335
/* 
241
336
 * Initialize GPGME.
242
337
 */
243
 
static bool init_gpgme(const char *seckey, const char *pubkey,
244
 
                       const char *tempdir){
 
338
__attribute__((nonnull, warn_unused_result))
 
339
static bool init_gpgme(const char * const seckey,
 
340
                       const char * const pubkey,
 
341
                       const char * const tempdir,
 
342
                       mandos_context *mc){
245
343
  gpgme_error_t rc;
246
344
  gpgme_engine_info_t engine_info;
247
345
  
248
 
  
249
346
  /*
250
347
   * Helper function to insert pub and seckey to the engine keyring.
251
348
   */
252
 
  bool import_key(const char *filename){
 
349
  bool import_key(const char * const filename){
253
350
    int ret;
254
351
    int fd;
255
352
    gpgme_data_t pgp_data;
260
357
      return false;
261
358
    }
262
359
    
 
360
    /* Workaround for systems without a real-time clock; see also
 
361
       Debian bug #894495: <https://bugs.debian.org/894495> */
 
362
    do {
 
363
      {
 
364
        time_t currtime = time(NULL);
 
365
        if(currtime != (time_t)-1){
 
366
          struct tm tm;
 
367
          if(gmtime_r(&currtime, &tm) == NULL) {
 
368
            perror_plus("gmtime_r");
 
369
            break;
 
370
          }
 
371
          if(tm.tm_year != 70 or tm.tm_mon != 0){
 
372
            break;
 
373
          }
 
374
          if(debug){
 
375
            fprintf_plus(stderr, "System clock is January 1970");
 
376
          }
 
377
        } else {
 
378
          if(debug){
 
379
            fprintf_plus(stderr, "System clock is invalid");
 
380
          }
 
381
        }
 
382
      }
 
383
      struct stat keystat;
 
384
      ret = fstat(fd, &keystat);
 
385
      if(ret != 0){
 
386
        perror_plus("fstat");
 
387
        break;
 
388
      }
 
389
      ret = raise_privileges();
 
390
      if(ret != 0){
 
391
        errno = ret;
 
392
        perror_plus("Failed to raise privileges");
 
393
        break;
 
394
      }
 
395
      if(debug){
 
396
        fprintf_plus(stderr,
 
397
                     "Setting system clock to key file mtime");
 
398
      }
 
399
      time_t keytime = keystat.st_mtim.tv_sec;
 
400
      if(stime(&keytime) != 0){
 
401
        perror_plus("stime");
 
402
      }
 
403
      ret = lower_privileges();
 
404
      if(ret != 0){
 
405
        errno = ret;
 
406
        perror_plus("Failed to lower privileges");
 
407
      }
 
408
    } while(false);
 
409
 
263
410
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
264
411
    if(rc != GPG_ERR_NO_ERROR){
265
412
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
267
414
      return false;
268
415
    }
269
416
    
270
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
417
    rc = gpgme_op_import(mc->ctx, pgp_data);
271
418
    if(rc != GPG_ERR_NO_ERROR){
272
419
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
273
420
                   gpgme_strsource(rc), gpgme_strerror(rc));
274
421
      return false;
275
422
    }
 
423
    {
 
424
      gpgme_import_result_t import_result
 
425
        = gpgme_op_import_result(mc->ctx);
 
426
      if((import_result->imported < 1
 
427
          or import_result->not_imported > 0)
 
428
         and import_result->unchanged == 0){
 
429
        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
 
430
        fprintf_plus(stderr,
 
431
                     "The total number of considered keys: %d\n",
 
432
                     import_result->considered);
 
433
        fprintf_plus(stderr,
 
434
                     "The number of keys without user ID: %d\n",
 
435
                     import_result->no_user_id);
 
436
        fprintf_plus(stderr,
 
437
                     "The total number of imported keys: %d\n",
 
438
                     import_result->imported);
 
439
        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
 
440
                     import_result->imported_rsa);
 
441
        fprintf_plus(stderr, "The number of unchanged keys: %d\n",
 
442
                     import_result->unchanged);
 
443
        fprintf_plus(stderr, "The number of new user IDs: %d\n",
 
444
                     import_result->new_user_ids);
 
445
        fprintf_plus(stderr, "The number of new sub keys: %d\n",
 
446
                     import_result->new_sub_keys);
 
447
        fprintf_plus(stderr, "The number of new signatures: %d\n",
 
448
                     import_result->new_signatures);
 
449
        fprintf_plus(stderr, "The number of new revocations: %d\n",
 
450
                     import_result->new_revocations);
 
451
        fprintf_plus(stderr,
 
452
                     "The total number of secret keys read: %d\n",
 
453
                     import_result->secret_read);
 
454
        fprintf_plus(stderr,
 
455
                     "The number of imported secret keys: %d\n",
 
456
                     import_result->secret_imported);
 
457
        fprintf_plus(stderr,
 
458
                     "The number of unchanged secret keys: %d\n",
 
459
                     import_result->secret_unchanged);
 
460
        fprintf_plus(stderr, "The number of keys not imported: %d\n",
 
461
                     import_result->not_imported);
 
462
        for(gpgme_import_status_t import_status
 
463
              = import_result->imports;
 
464
            import_status != NULL;
 
465
            import_status = import_status->next){
 
466
          fprintf_plus(stderr, "Import status for key: %s\n",
 
467
                       import_status->fpr);
 
468
          if(import_status->result != GPG_ERR_NO_ERROR){
 
469
            fprintf_plus(stderr, "Import result: %s: %s\n",
 
470
                         gpgme_strsource(import_status->result),
 
471
                         gpgme_strerror(import_status->result));
 
472
          }
 
473
          fprintf_plus(stderr, "Key status:\n");
 
474
          fprintf_plus(stderr,
 
475
                       import_status->status & GPGME_IMPORT_NEW
 
476
                       ? "The key was new.\n"
 
477
                       : "The key was not new.\n");
 
478
          fprintf_plus(stderr,
 
479
                       import_status->status & GPGME_IMPORT_UID
 
480
                       ? "The key contained new user IDs.\n"
 
481
                       : "The key did not contain new user IDs.\n");
 
482
          fprintf_plus(stderr,
 
483
                       import_status->status & GPGME_IMPORT_SIG
 
484
                       ? "The key contained new signatures.\n"
 
485
                       : "The key did not contain new signatures.\n");
 
486
          fprintf_plus(stderr,
 
487
                       import_status->status & GPGME_IMPORT_SUBKEY
 
488
                       ? "The key contained new sub keys.\n"
 
489
                       : "The key did not contain new sub keys.\n");
 
490
          fprintf_plus(stderr,
 
491
                       import_status->status & GPGME_IMPORT_SECRET
 
492
                       ? "The key contained a secret key.\n"
 
493
                       : "The key did not contain a secret key.\n");
 
494
        }
 
495
        return false;
 
496
      }
 
497
    }
276
498
    
277
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
499
    ret = close(fd);
278
500
    if(ret == -1){
279
501
      perror_plus("close");
280
502
    }
317
539
  }
318
540
  
319
541
  /* Create new GPGME "context" */
320
 
  rc = gpgme_new(&(mc.ctx));
 
542
  rc = gpgme_new(&(mc->ctx));
321
543
  if(rc != GPG_ERR_NO_ERROR){
322
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
323
 
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
324
 
                 gpgme_strerror(rc));
 
544
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
 
545
                 gpgme_strsource(rc), gpgme_strerror(rc));
325
546
    return false;
326
547
  }
327
548
  
336
557
 * Decrypt OpenPGP data.
337
558
 * Returns -1 on error
338
559
 */
 
560
__attribute__((nonnull, warn_unused_result))
339
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
340
562
                                  size_t crypto_size,
341
 
                                  char **plaintext){
 
563
                                  char **plaintext,
 
564
                                  mandos_context *mc){
342
565
  gpgme_data_t dh_crypto, dh_plain;
343
566
  gpgme_error_t rc;
344
567
  ssize_t ret;
361
584
  /* Create new empty GPGME data buffer for the plaintext */
362
585
  rc = gpgme_data_new(&dh_plain);
363
586
  if(rc != GPG_ERR_NO_ERROR){
364
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
365
 
                 "bad gpgme_data_new: %s: %s\n",
 
587
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
366
588
                 gpgme_strsource(rc), gpgme_strerror(rc));
367
589
    gpgme_data_release(dh_crypto);
368
590
    return -1;
370
592
  
371
593
  /* Decrypt data from the cryptotext data buffer to the plaintext
372
594
     data buffer */
373
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
595
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
374
596
  if(rc != GPG_ERR_NO_ERROR){
375
597
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
376
598
                 gpgme_strsource(rc), gpgme_strerror(rc));
377
599
    plaintext_length = -1;
378
600
    if(debug){
379
601
      gpgme_decrypt_result_t result;
380
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
602
      result = gpgme_op_decrypt_result(mc->ctx);
381
603
      if(result == NULL){
382
604
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
383
605
      } else {
384
 
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
385
 
                     result->unsupported_algorithm);
386
 
        fprintf_plus(stderr, "Wrong key usage: %u\n",
387
 
                     result->wrong_key_usage);
 
606
        if(result->unsupported_algorithm != NULL) {
 
607
          fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
608
                       result->unsupported_algorithm);
 
609
        }
 
610
        fprintf_plus(stderr, "Wrong key usage: %s\n",
 
611
                     result->wrong_key_usage ? "Yes" : "No");
388
612
        if(result->file_name != NULL){
389
613
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
390
614
        }
391
 
        gpgme_recipient_t recipient;
392
 
        recipient = result->recipients;
393
 
        while(recipient != NULL){
 
615
 
 
616
        for(gpgme_recipient_t r = result->recipients; r != NULL;
 
617
            r = r->next){
394
618
          fprintf_plus(stderr, "Public key algorithm: %s\n",
395
 
                       gpgme_pubkey_algo_name
396
 
                       (recipient->pubkey_algo));
397
 
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
619
                       gpgme_pubkey_algo_name(r->pubkey_algo));
 
620
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
398
621
          fprintf_plus(stderr, "Secret key available: %s\n",
399
 
                       recipient->status == GPG_ERR_NO_SECKEY
400
 
                       ? "No" : "Yes");
401
 
          recipient = recipient->next;
 
622
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
402
623
        }
403
624
      }
404
625
    }
460
681
  return plaintext_length;
461
682
}
462
683
 
463
 
static const char * safer_gnutls_strerror(int value){
464
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
465
 
                                               -Wunreachable-code */
466
 
  if(ret == NULL)
467
 
    ret = "(unknown)";
468
 
  return ret;
 
684
__attribute__((warn_unused_result, const))
 
685
static const char *safe_string(const char *str){
 
686
  if(str == NULL)
 
687
    return "(unknown)";
 
688
  return str;
 
689
}
 
690
 
 
691
__attribute__((warn_unused_result))
 
692
static const char *safer_gnutls_strerror(int value){
 
693
  const char *ret = gnutls_strerror(value);
 
694
  return safe_string(ret);
469
695
}
470
696
 
471
697
/* GnuTLS log function callback */
 
698
__attribute__((nonnull))
472
699
static void debuggnutls(__attribute__((unused)) int level,
473
700
                        const char* string){
474
701
  fprintf_plus(stderr, "GnuTLS: %s", string);
475
702
}
476
703
 
 
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
477
705
static int init_gnutls_global(const char *pubkeyfilename,
478
 
                              const char *seckeyfilename){
 
706
                              const char *seckeyfilename,
 
707
                              const char *dhparamsfilename,
 
708
                              mandos_context *mc){
479
709
  int ret;
480
710
  
481
711
  if(debug){
482
712
    fprintf_plus(stderr, "Initializing GnuTLS\n");
483
713
  }
484
714
  
485
 
  ret = gnutls_global_init();
486
 
  if(ret != GNUTLS_E_SUCCESS){
487
 
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
488
 
                 safer_gnutls_strerror(ret));
489
 
    return -1;
490
 
  }
491
 
  
492
715
  if(debug){
493
716
    /* "Use a log level over 10 to enable all debugging options."
494
717
     * - GnuTLS manual
498
721
  }
499
722
  
500
723
  /* OpenPGP credentials */
501
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
724
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
502
725
  if(ret != GNUTLS_E_SUCCESS){
503
726
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
504
727
                 safer_gnutls_strerror(ret));
505
 
    gnutls_global_deinit();
506
728
    return -1;
507
729
  }
508
730
  
509
731
  if(debug){
510
 
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
511
 
                 " secret key %s as GnuTLS credentials\n",
 
732
    fprintf_plus(stderr, "Attempting to use public key %s and"
 
733
                 " private key %s as GnuTLS credentials\n",
512
734
                 pubkeyfilename,
513
735
                 seckeyfilename);
514
736
  }
515
737
  
 
738
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
739
  ret = gnutls_certificate_set_rawpk_key_file
 
740
    (mc->cred, pubkeyfilename, seckeyfilename,
 
741
     GNUTLS_X509_FMT_PEM,       /* format */
 
742
     NULL,                      /* pass */
 
743
     /* key_usage */
 
744
     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
 
745
     NULL,                      /* names */
 
746
     0,                         /* names_length */
 
747
     /* privkey_flags */
 
748
     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
 
749
     0);                        /* pkcs11_flags */
 
750
#elif GNUTLS_VERSION_NUMBER < 0x030600
516
751
  ret = gnutls_certificate_set_openpgp_key_file
517
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
752
    (mc->cred, pubkeyfilename, seckeyfilename,
518
753
     GNUTLS_OPENPGP_FMT_BASE64);
 
754
#else
 
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
756
#endif
519
757
  if(ret != GNUTLS_E_SUCCESS){
520
758
    fprintf_plus(stderr,
521
 
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
759
                 "Error[%d] while reading the key pair ('%s',"
522
760
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
523
761
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
524
762
                 safer_gnutls_strerror(ret));
526
764
  }
527
765
  
528
766
  /* GnuTLS server initialization */
529
 
  ret = gnutls_dh_params_init(&mc.dh_params);
 
767
  ret = gnutls_dh_params_init(&mc->dh_params);
530
768
  if(ret != GNUTLS_E_SUCCESS){
531
769
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
532
770
                 " initialization: %s\n",
533
771
                 safer_gnutls_strerror(ret));
534
772
    goto globalfail;
535
773
  }
536
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
537
 
  if(ret != GNUTLS_E_SUCCESS){
538
 
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
539
 
                 safer_gnutls_strerror(ret));
540
 
    goto globalfail;
541
 
  }
542
 
  
543
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
774
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
775
  if(dhparamsfilename != NULL){
 
776
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
777
    do {
 
778
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
779
      if(dhpfile == -1){
 
780
        perror_plus("open");
 
781
        dhparamsfilename = NULL;
 
782
        break;
 
783
      }
 
784
      size_t params_capacity = 0;
 
785
      while(true){
 
786
        params_capacity = incbuffer((char **)&params.data,
 
787
                                    (size_t)params.size,
 
788
                                    (size_t)params_capacity);
 
789
        if(params_capacity == 0){
 
790
          perror_plus("incbuffer");
 
791
          free(params.data);
 
792
          params.data = NULL;
 
793
          dhparamsfilename = NULL;
 
794
          break;
 
795
        }
 
796
        ssize_t bytes_read = read(dhpfile,
 
797
                                  params.data + params.size,
 
798
                                  BUFFER_SIZE);
 
799
        /* EOF */
 
800
        if(bytes_read == 0){
 
801
          break;
 
802
        }
 
803
        /* check bytes_read for failure */
 
804
        if(bytes_read < 0){
 
805
          perror_plus("read");
 
806
          free(params.data);
 
807
          params.data = NULL;
 
808
          dhparamsfilename = NULL;
 
809
          break;
 
810
        }
 
811
        params.size += (unsigned int)bytes_read;
 
812
      }
 
813
      ret = close(dhpfile);
 
814
      if(ret == -1){
 
815
        perror_plus("close");
 
816
      }
 
817
      if(params.data == NULL){
 
818
        dhparamsfilename = NULL;
 
819
      }
 
820
      if(dhparamsfilename == NULL){
 
821
        break;
 
822
      }
 
823
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
 
824
                                          GNUTLS_X509_FMT_PEM);
 
825
      if(ret != GNUTLS_E_SUCCESS){
 
826
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
 
827
                     " \"%s\": %s\n", dhparamsfilename,
 
828
                     safer_gnutls_strerror(ret));
 
829
        dhparamsfilename = NULL;
 
830
      }
 
831
      free(params.data);
 
832
    } while(false);
 
833
  }
 
834
  if(dhparamsfilename == NULL){
 
835
    if(mc->dh_bits == 0){
 
836
#if GNUTLS_VERSION_NUMBER < 0x030600
 
837
      /* Find out the optimal number of DH bits */
 
838
      /* Try to read the private key file */
 
839
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
840
      do {
 
841
        int secfile = open(seckeyfilename, O_RDONLY);
 
842
        if(secfile == -1){
 
843
          perror_plus("open");
 
844
          break;
 
845
        }
 
846
        size_t buffer_capacity = 0;
 
847
        while(true){
 
848
          buffer_capacity = incbuffer((char **)&buffer.data,
 
849
                                      (size_t)buffer.size,
 
850
                                      (size_t)buffer_capacity);
 
851
          if(buffer_capacity == 0){
 
852
            perror_plus("incbuffer");
 
853
            free(buffer.data);
 
854
            buffer.data = NULL;
 
855
            break;
 
856
          }
 
857
          ssize_t bytes_read = read(secfile,
 
858
                                    buffer.data + buffer.size,
 
859
                                    BUFFER_SIZE);
 
860
          /* EOF */
 
861
          if(bytes_read == 0){
 
862
            break;
 
863
          }
 
864
          /* check bytes_read for failure */
 
865
          if(bytes_read < 0){
 
866
            perror_plus("read");
 
867
            free(buffer.data);
 
868
            buffer.data = NULL;
 
869
            break;
 
870
          }
 
871
          buffer.size += (unsigned int)bytes_read;
 
872
        }
 
873
        close(secfile);
 
874
      } while(false);
 
875
      /* If successful, use buffer to parse private key */
 
876
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
877
      if(buffer.data != NULL){
 
878
        {
 
879
          gnutls_openpgp_privkey_t privkey = NULL;
 
880
          ret = gnutls_openpgp_privkey_init(&privkey);
 
881
          if(ret != GNUTLS_E_SUCCESS){
 
882
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
883
                         " structure: %s",
 
884
                         safer_gnutls_strerror(ret));
 
885
            free(buffer.data);
 
886
            buffer.data = NULL;
 
887
          } else {
 
888
            ret = gnutls_openpgp_privkey_import
 
889
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
 
890
            if(ret != GNUTLS_E_SUCCESS){
 
891
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
892
                           safer_gnutls_strerror(ret));
 
893
              privkey = NULL;
 
894
            }
 
895
            free(buffer.data);
 
896
            buffer.data = NULL;
 
897
            if(privkey != NULL){
 
898
              /* Use private key to suggest an appropriate
 
899
                 sec_param */
 
900
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
901
              gnutls_openpgp_privkey_deinit(privkey);
 
902
              if(debug){
 
903
                fprintf_plus(stderr, "This OpenPGP key implies using"
 
904
                             " a GnuTLS security parameter \"%s\".\n",
 
905
                             safe_string(gnutls_sec_param_get_name
 
906
                                         (sec_param)));
 
907
              }
 
908
            }
 
909
          }
 
910
        }
 
911
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
912
          /* Err on the side of caution */
 
913
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
914
          if(debug){
 
915
            fprintf_plus(stderr, "Falling back to security parameter"
 
916
                         " \"%s\"\n",
 
917
                         safe_string(gnutls_sec_param_get_name
 
918
                                     (sec_param)));
 
919
          }
 
920
        }
 
921
      }
 
922
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
923
      if(uret != 0){
 
924
        mc->dh_bits = uret;
 
925
        if(debug){
 
926
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
927
                       " implies %u DH bits; using that.\n",
 
928
                       safe_string(gnutls_sec_param_get_name
 
929
                                   (sec_param)),
 
930
                       mc->dh_bits);
 
931
        }
 
932
      } else {
 
933
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
934
                     " bits for security parameter \"%s\"): %s\n",
 
935
                     safe_string(gnutls_sec_param_get_name
 
936
                                 (sec_param)),
 
937
                     safer_gnutls_strerror(ret));
 
938
        goto globalfail;
 
939
      }
 
940
#endif
 
941
    } else {                    /* dh_bits != 0 */
 
942
      if(debug){
 
943
        fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
944
                     mc->dh_bits);
 
945
      }
 
946
      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
947
      if(ret != GNUTLS_E_SUCCESS){
 
948
        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
 
949
                     " bits): %s\n", mc->dh_bits,
 
950
                     safer_gnutls_strerror(ret));
 
951
        goto globalfail;
 
952
      }
 
953
      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
954
    }
 
955
  }
544
956
  
545
957
  return 0;
546
958
  
547
959
 globalfail:
548
960
  
549
 
  gnutls_certificate_free_credentials(mc.cred);
550
 
  gnutls_global_deinit();
551
 
  gnutls_dh_params_deinit(mc.dh_params);
 
961
  gnutls_certificate_free_credentials(mc->cred);
 
962
  gnutls_dh_params_deinit(mc->dh_params);
552
963
  return -1;
553
964
}
554
965
 
555
 
static int init_gnutls_session(gnutls_session_t *session){
 
966
__attribute__((nonnull, warn_unused_result))
 
967
static int init_gnutls_session(gnutls_session_t *session,
 
968
                               mandos_context *mc){
556
969
  int ret;
557
970
  /* GnuTLS session creation */
558
971
  do {
559
 
    ret = gnutls_init(session, GNUTLS_SERVER);
 
972
    ret = gnutls_init(session, (GNUTLS_SERVER
 
973
#if GNUTLS_VERSION_NUMBER >= 0x030506
 
974
                                | GNUTLS_NO_TICKETS
 
975
#endif
 
976
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
977
                                | GNUTLS_ENABLE_RAWPK
 
978
#endif
 
979
                                ));
560
980
    if(quit_now){
561
981
      return -1;
562
982
    }
570
990
  {
571
991
    const char *err;
572
992
    do {
573
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
993
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
574
994
      if(quit_now){
575
995
        gnutls_deinit(*session);
576
996
        return -1;
587
1007
  
588
1008
  do {
589
1009
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
590
 
                                 mc.cred);
 
1010
                                 mc->cred);
591
1011
    if(quit_now){
592
1012
      gnutls_deinit(*session);
593
1013
      return -1;
603
1023
  /* ignore client certificate if any. */
604
1024
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
605
1025
  
606
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
607
 
  
608
1026
  return 0;
609
1027
}
610
1028
 
612
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
613
1031
                      __attribute__((unused)) const char *txt){}
614
1032
 
 
1033
/* Helper function to add_local_route() and delete_local_route() */
 
1034
__attribute__((nonnull, warn_unused_result))
 
1035
static bool add_delete_local_route(const bool add,
 
1036
                                   const char *address,
 
1037
                                   AvahiIfIndex if_index){
 
1038
  int ret;
 
1039
  char helper[] = "mandos-client-iprouteadddel";
 
1040
  char add_arg[] = "add";
 
1041
  char delete_arg[] = "delete";
 
1042
  char debug_flag[] = "--debug";
 
1043
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
 
1044
  if(pluginhelperdir == NULL){
 
1045
    if(debug){
 
1046
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
 
1047
                   " variable not set; cannot run helper\n");
 
1048
    }
 
1049
    return false;
 
1050
  }
 
1051
  
 
1052
  char interface[IF_NAMESIZE];
 
1053
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1054
    perror_plus("if_indextoname");
 
1055
    return false;
 
1056
  }
 
1057
  
 
1058
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
1059
  if(devnull == -1){
 
1060
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
1061
    return false;
 
1062
  }
 
1063
  pid_t pid = fork();
 
1064
  if(pid == 0){
 
1065
    /* Child */
 
1066
    /* Raise privileges */
 
1067
    errno = raise_privileges_permanently();
 
1068
    if(errno != 0){
 
1069
      perror_plus("Failed to raise privileges");
 
1070
      /* _exit(EX_NOPERM); */
 
1071
    } else {
 
1072
      /* Set group */
 
1073
      errno = 0;
 
1074
      ret = setgid(0);
 
1075
      if(ret == -1){
 
1076
        perror_plus("setgid");
 
1077
        _exit(EX_NOPERM);
 
1078
      }
 
1079
      /* Reset supplementary groups */
 
1080
      errno = 0;
 
1081
      ret = setgroups(0, NULL);
 
1082
      if(ret == -1){
 
1083
        perror_plus("setgroups");
 
1084
        _exit(EX_NOPERM);
 
1085
      }
 
1086
    }
 
1087
    ret = dup2(devnull, STDIN_FILENO);
 
1088
    if(ret == -1){
 
1089
      perror_plus("dup2(devnull, STDIN_FILENO)");
 
1090
      _exit(EX_OSERR);
 
1091
    }
 
1092
    ret = close(devnull);
 
1093
    if(ret == -1){
 
1094
      perror_plus("close");
 
1095
      _exit(EX_OSERR);
 
1096
    }
 
1097
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1098
    if(ret == -1){
 
1099
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1100
      _exit(EX_OSERR);
 
1101
    }
 
1102
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
 
1103
                                                    O_RDONLY
 
1104
                                                    | O_DIRECTORY
 
1105
                                                    | O_PATH
 
1106
                                                    | O_CLOEXEC));
 
1107
    if(helperdir_fd == -1){
 
1108
      perror_plus("open");
 
1109
      _exit(EX_UNAVAILABLE);
 
1110
    }
 
1111
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
 
1112
                                                   helper, O_RDONLY));
 
1113
    if(helper_fd == -1){
 
1114
      perror_plus("openat");
 
1115
      close(helperdir_fd);
 
1116
      _exit(EX_UNAVAILABLE);
 
1117
    }
 
1118
    close(helperdir_fd);
 
1119
#ifdef __GNUC__
 
1120
#pragma GCC diagnostic push
 
1121
#pragma GCC diagnostic ignored "-Wcast-qual"
 
1122
#endif
 
1123
    if(fexecve(helper_fd, (char *const [])
 
1124
               { helper, add ? add_arg : delete_arg, (char *)address,
 
1125
                   interface, debug ? debug_flag : NULL, NULL },
 
1126
               environ) == -1){
 
1127
#ifdef __GNUC__
 
1128
#pragma GCC diagnostic pop
 
1129
#endif
 
1130
      perror_plus("fexecve");
 
1131
      _exit(EXIT_FAILURE);
 
1132
    }
 
1133
  }
 
1134
  if(pid == -1){
 
1135
    perror_plus("fork");
 
1136
    return false;
 
1137
  }
 
1138
  int status;
 
1139
  pid_t pret = -1;
 
1140
  errno = 0;
 
1141
  do {
 
1142
    pret = waitpid(pid, &status, 0);
 
1143
    if(pret == -1 and errno == EINTR and quit_now){
 
1144
      int errno_raising = 0;
 
1145
      if((errno = raise_privileges()) != 0){
 
1146
        errno_raising = errno;
 
1147
        perror_plus("Failed to raise privileges in order to"
 
1148
                    " kill helper program");
 
1149
      }
 
1150
      if(kill(pid, SIGTERM) == -1){
 
1151
        perror_plus("kill");
 
1152
      }
 
1153
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
 
1154
        perror_plus("Failed to lower privileges after killing"
 
1155
                    " helper program");
 
1156
      }
 
1157
      return false;
 
1158
    }
 
1159
  } while(pret == -1 and errno == EINTR);
 
1160
  if(pret == -1){
 
1161
    perror_plus("waitpid");
 
1162
    return false;
 
1163
  }
 
1164
  if(WIFEXITED(status)){
 
1165
    if(WEXITSTATUS(status) != 0){
 
1166
      fprintf_plus(stderr, "Error: iprouteadddel exited"
 
1167
                   " with status %d\n", WEXITSTATUS(status));
 
1168
      return false;
 
1169
    }
 
1170
    return true;
 
1171
  }
 
1172
  if(WIFSIGNALED(status)){
 
1173
    fprintf_plus(stderr, "Error: iprouteadddel died by"
 
1174
                 " signal %d\n", WTERMSIG(status));
 
1175
    return false;
 
1176
  }
 
1177
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
 
1178
  return false;
 
1179
}
 
1180
 
 
1181
__attribute__((nonnull, warn_unused_result))
 
1182
static bool add_local_route(const char *address,
 
1183
                            AvahiIfIndex if_index){
 
1184
  if(debug){
 
1185
    fprintf_plus(stderr, "Adding route to %s\n", address);
 
1186
  }
 
1187
  return add_delete_local_route(true, address, if_index);
 
1188
}
 
1189
 
 
1190
__attribute__((nonnull, warn_unused_result))
 
1191
static bool delete_local_route(const char *address,
 
1192
                               AvahiIfIndex if_index){
 
1193
  if(debug){
 
1194
    fprintf_plus(stderr, "Removing route to %s\n", address);
 
1195
  }
 
1196
  return add_delete_local_route(false, address, if_index);
 
1197
}
 
1198
 
615
1199
/* Called when a Mandos server is found */
616
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
1200
__attribute__((nonnull, warn_unused_result))
 
1201
static int start_mandos_communication(const char *ip, in_port_t port,
617
1202
                                      AvahiIfIndex if_index,
618
 
                                      int af){
 
1203
                                      int af, mandos_context *mc){
619
1204
  int ret, tcp_sd = -1;
620
1205
  ssize_t sret;
621
 
  union {
622
 
    struct sockaddr_in in;
623
 
    struct sockaddr_in6 in6;
624
 
  } to;
 
1206
  struct sockaddr_storage to;
625
1207
  char *buffer = NULL;
626
1208
  char *decrypted_buffer = NULL;
627
1209
  size_t buffer_length = 0;
630
1212
  int retval = -1;
631
1213
  gnutls_session_t session;
632
1214
  int pf;                       /* Protocol family */
 
1215
  bool route_added = false;
633
1216
  
634
1217
  errno = 0;
635
1218
  
651
1234
    return -1;
652
1235
  }
653
1236
  
654
 
  ret = init_gnutls_session(&session);
 
1237
  /* If the interface is specified and we have a list of interfaces */
 
1238
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
1239
    /* Check if the interface is one of the interfaces we are using */
 
1240
    bool match = false;
 
1241
    {
 
1242
      char *interface = NULL;
 
1243
      while((interface = argz_next(mc->interfaces,
 
1244
                                   mc->interfaces_size,
 
1245
                                   interface))){
 
1246
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
1247
          match = true;
 
1248
          break;
 
1249
        }
 
1250
      }
 
1251
    }
 
1252
    if(not match){
 
1253
      /* This interface does not match any in the list, so we don't
 
1254
         connect to the server */
 
1255
      if(debug){
 
1256
        char interface[IF_NAMESIZE];
 
1257
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1258
          perror_plus("if_indextoname");
 
1259
        } else {
 
1260
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
1261
                       " \"%s\"\n",
 
1262
                       if_indextoname((unsigned int)if_index,
 
1263
                                      interface));
 
1264
        }
 
1265
      }
 
1266
      return -1;
 
1267
    }
 
1268
  }
 
1269
  
 
1270
  ret = init_gnutls_session(&session, mc);
655
1271
  if(ret != 0){
656
1272
    return -1;
657
1273
  }
658
1274
  
659
1275
  if(debug){
660
1276
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
661
 
                 PRIu16 "\n", ip, port);
 
1277
                 PRIuMAX "\n", ip, (uintmax_t)port);
662
1278
  }
663
1279
  
664
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1280
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
665
1281
  if(tcp_sd < 0){
666
1282
    int e = errno;
667
1283
    perror_plus("socket");
674
1290
    goto mandos_end;
675
1291
  }
676
1292
  
677
 
  memset(&to, 0, sizeof(to));
678
1293
  if(af == AF_INET6){
679
 
    to.in6.sin6_family = (sa_family_t)af;
680
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
1294
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1295
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1296
    ret = inet_pton(af, ip, &to6->sin6_addr);
681
1297
  } else {                      /* IPv4 */
682
 
    to.in.sin_family = (sa_family_t)af;
683
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
1298
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1299
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1300
    ret = inet_pton(af, ip, &to4->sin_addr);
684
1301
  }
685
1302
  if(ret < 0 ){
686
1303
    int e = errno;
695
1312
    goto mandos_end;
696
1313
  }
697
1314
  if(af == AF_INET6){
698
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
699
 
                                       -Wconversion and
700
 
                                       -Wunreachable-code */
701
 
    
702
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
703
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
704
 
                                -Wunreachable-code*/
 
1315
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
1316
    if(IN6_IS_ADDR_LINKLOCAL
 
1317
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
705
1318
      if(if_index == AVAHI_IF_UNSPEC){
706
1319
        fprintf_plus(stderr, "An IPv6 link-local address is"
707
1320
                     " incomplete without a network interface\n");
709
1322
        goto mandos_end;
710
1323
      }
711
1324
      /* Set the network interface number as scope */
712
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
1325
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
713
1326
    }
714
1327
  } else {
715
 
    to.in.sin_port = htons(port); /* Spurious warnings from
716
 
                                     -Wconversion and
717
 
                                     -Wunreachable-code */
 
1328
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
718
1329
  }
719
1330
  
720
1331
  if(quit_now){
728
1339
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
729
1340
        perror_plus("if_indextoname");
730
1341
      } else {
731
 
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
732
 
                     "\n", ip, interface, port);
 
1342
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
1343
                     "\n", ip, interface, (uintmax_t)port);
733
1344
      }
734
1345
    } else {
735
 
      fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
736
 
                   ip, port);
 
1346
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
1347
                   ip, (uintmax_t)port);
737
1348
    }
738
1349
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
739
1350
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
740
 
    const char *pcret;
741
 
    if(af == AF_INET6){
742
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
743
 
                        sizeof(addrstr));
744
 
    } else {
745
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
746
 
                        sizeof(addrstr));
747
 
    }
748
 
    if(pcret == NULL){
749
 
      perror_plus("inet_ntop");
750
 
    } else {
751
 
      if(strcmp(addrstr, ip) != 0){
752
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
753
 
      }
754
 
    }
755
 
  }
756
 
  
757
 
  if(quit_now){
758
 
    errno = EINTR;
759
 
    goto mandos_end;
760
 
  }
761
 
  
762
 
  if(af == AF_INET6){
763
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
764
 
  } else {
765
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
766
 
  }
767
 
  if(ret < 0){
768
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
769
 
      int e = errno;
770
 
      perror_plus("connect");
771
 
      errno = e;
772
 
    }
773
 
    goto mandos_end;
774
 
  }
775
 
  
776
 
  if(quit_now){
777
 
    errno = EINTR;
778
 
    goto mandos_end;
 
1351
    if(af == AF_INET6){
 
1352
      ret = getnameinfo((struct sockaddr *)&to,
 
1353
                        sizeof(struct sockaddr_in6),
 
1354
                        addrstr, sizeof(addrstr), NULL, 0,
 
1355
                        NI_NUMERICHOST);
 
1356
    } else {
 
1357
      ret = getnameinfo((struct sockaddr *)&to,
 
1358
                        sizeof(struct sockaddr_in),
 
1359
                        addrstr, sizeof(addrstr), NULL, 0,
 
1360
                        NI_NUMERICHOST);
 
1361
    }
 
1362
    if(ret == EAI_SYSTEM){
 
1363
      perror_plus("getnameinfo");
 
1364
    } else if(ret != 0) {
 
1365
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
1366
    } else if(strcmp(addrstr, ip) != 0){
 
1367
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
 
1368
    }
 
1369
  }
 
1370
  
 
1371
  if(quit_now){
 
1372
    errno = EINTR;
 
1373
    goto mandos_end;
 
1374
  }
 
1375
  
 
1376
  while(true){
 
1377
    if(af == AF_INET6){
 
1378
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1379
                    sizeof(struct sockaddr_in6));
 
1380
    } else {
 
1381
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1382
                    sizeof(struct sockaddr_in));
 
1383
    }
 
1384
    if(ret < 0){
 
1385
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
 
1386
         and if_index != AVAHI_IF_UNSPEC
 
1387
         and connect_to == NULL
 
1388
         and not route_added and
 
1389
         ((af == AF_INET6 and not
 
1390
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1391
                                    &to)->sin6_addr)))
 
1392
          or (af == AF_INET and
 
1393
              /* Not a a IPv4LL address */
 
1394
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1395
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1396
        /* Work around Avahi bug - Avahi does not announce link-local
 
1397
           addresses if it has a global address, so local hosts with
 
1398
           *only* a link-local address (e.g. Mandos clients) cannot
 
1399
           connect to a Mandos server announced by Avahi on a server
 
1400
           host with a global address.  Work around this by retrying
 
1401
           with an explicit route added with the server's address.
 
1402
           
 
1403
           Avahi bug reference:
 
1404
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1405
           https://bugs.debian.org/587961
 
1406
        */
 
1407
        if(debug){
 
1408
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1409
                       " direct route\n");
 
1410
        }
 
1411
        int e = errno;
 
1412
        route_added = add_local_route(ip, if_index);
 
1413
        if(route_added){
 
1414
          continue;
 
1415
        }
 
1416
        errno = e;
 
1417
      }
 
1418
      if(errno != ECONNREFUSED or debug){
 
1419
        int e = errno;
 
1420
        perror_plus("connect");
 
1421
        errno = e;
 
1422
      }
 
1423
      goto mandos_end;
 
1424
    }
 
1425
    
 
1426
    if(quit_now){
 
1427
      errno = EINTR;
 
1428
      goto mandos_end;
 
1429
    }
 
1430
    break;
779
1431
  }
780
1432
  
781
1433
  const char *out = mandos_protocol_version;
817
1469
    goto mandos_end;
818
1470
  }
819
1471
  
820
 
  /* Spurious warning from -Wint-to-pointer-cast */
821
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
1472
  /* This casting via intptr_t is to eliminate warning about casting
 
1473
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
1474
     function "set-session-transport-fd!" does it. */
 
1475
  gnutls_transport_set_ptr(session,
 
1476
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
822
1477
  
823
1478
  if(quit_now){
824
1479
    errno = EINTR;
929
1584
  if(buffer_length > 0){
930
1585
    ssize_t decrypted_buffer_size;
931
1586
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
932
 
                                               &decrypted_buffer);
 
1587
                                               &decrypted_buffer, mc);
933
1588
    if(decrypted_buffer_size >= 0){
934
1589
      
 
1590
      clearerr(stdout);
935
1591
      written = 0;
936
1592
      while(written < (size_t) decrypted_buffer_size){
937
1593
        if(quit_now){
953
1609
        }
954
1610
        written += (size_t)ret;
955
1611
      }
 
1612
      ret = fflush(stdout);
 
1613
      if(ret != 0){
 
1614
        int e = errno;
 
1615
        if(debug){
 
1616
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1617
                       strerror(errno));
 
1618
        }
 
1619
        errno = e;
 
1620
        goto mandos_end;
 
1621
      }
956
1622
      retval = 0;
957
1623
    }
958
1624
  }
961
1627
  
962
1628
 mandos_end:
963
1629
  {
 
1630
    if(route_added){
 
1631
      if(not delete_local_route(ip, if_index)){
 
1632
        fprintf_plus(stderr, "Failed to delete local route to %s on"
 
1633
                     " interface %d", ip, if_index);
 
1634
      }
 
1635
    }
964
1636
    int e = errno;
965
1637
    free(decrypted_buffer);
966
1638
    free(buffer);
967
1639
    if(tcp_sd >= 0){
968
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1640
      ret = close(tcp_sd);
969
1641
    }
970
1642
    if(ret == -1){
971
1643
      if(e == 0){
996
1668
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
997
1669
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
998
1670
                             flags,
999
 
                             AVAHI_GCC_UNUSED void* userdata){
1000
 
  assert(r);
 
1671
                             void *mc){
 
1672
  if(r == NULL){
 
1673
    return;
 
1674
  }
1001
1675
  
1002
1676
  /* Called whenever a service has been resolved successfully or
1003
1677
     timed out */
1004
1678
  
1005
1679
  if(quit_now){
 
1680
    avahi_s_service_resolver_free(r);
1006
1681
    return;
1007
1682
  }
1008
1683
  
1012
1687
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1013
1688
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
1014
1689
                 domain,
1015
 
                 avahi_strerror(avahi_server_errno(mc.server)));
 
1690
                 avahi_strerror(avahi_server_errno
 
1691
                                (((mandos_context*)mc)->server)));
1016
1692
    break;
1017
1693
    
1018
1694
  case AVAHI_RESOLVER_FOUND:
1024
1700
                     PRIdMAX ") on port %" PRIu16 "\n", name,
1025
1701
                     host_name, ip, (intmax_t)interface, port);
1026
1702
      }
1027
 
      int ret = start_mandos_communication(ip, port, interface,
1028
 
                                           avahi_proto_to_af(proto));
 
1703
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1704
                                           interface,
 
1705
                                           avahi_proto_to_af(proto),
 
1706
                                           mc);
1029
1707
      if(ret == 0){
1030
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1708
        avahi_simple_poll_quit(simple_poll);
1031
1709
      } else {
1032
 
        ret = add_server(ip, port, interface,
1033
 
                         avahi_proto_to_af(proto));
 
1710
        if(not add_server(ip, (in_port_t)port, interface,
 
1711
                          avahi_proto_to_af(proto),
 
1712
                          &((mandos_context*)mc)->current_server)){
 
1713
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1714
                       " list\n", name);
 
1715
        }
1034
1716
      }
1035
1717
    }
1036
1718
  }
1046
1728
                            const char *domain,
1047
1729
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1048
1730
                            flags,
1049
 
                            AVAHI_GCC_UNUSED void* userdata){
1050
 
  assert(b);
 
1731
                            void *mc){
 
1732
  if(b == NULL){
 
1733
    return;
 
1734
  }
1051
1735
  
1052
1736
  /* Called whenever a new services becomes available on the LAN or
1053
1737
     is removed from the LAN */
1061
1745
  case AVAHI_BROWSER_FAILURE:
1062
1746
    
1063
1747
    fprintf_plus(stderr, "(Avahi browser) %s\n",
1064
 
                 avahi_strerror(avahi_server_errno(mc.server)));
1065
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1748
                 avahi_strerror(avahi_server_errno
 
1749
                                (((mandos_context*)mc)->server)));
 
1750
    avahi_simple_poll_quit(simple_poll);
1066
1751
    return;
1067
1752
    
1068
1753
  case AVAHI_BROWSER_NEW:
1071
1756
       the callback function is called the Avahi server will free the
1072
1757
       resolver for us. */
1073
1758
    
1074
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1075
 
                                    name, type, domain, protocol, 0,
1076
 
                                    resolve_callback, NULL) == NULL)
 
1759
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1760
                                    interface, protocol, name, type,
 
1761
                                    domain, protocol, 0,
 
1762
                                    resolve_callback, mc) == NULL)
1077
1763
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1078
1764
                   " %s\n", name,
1079
 
                   avahi_strerror(avahi_server_errno(mc.server)));
 
1765
                   avahi_strerror(avahi_server_errno
 
1766
                                  (((mandos_context*)mc)->server)));
1080
1767
    break;
1081
1768
    
1082
1769
  case AVAHI_BROWSER_REMOVE:
1101
1788
  signal_received = sig;
1102
1789
  int old_errno = errno;
1103
1790
  /* set main loop to exit */
1104
 
  if(mc.simple_poll != NULL){
1105
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1791
  if(simple_poll != NULL){
 
1792
    avahi_simple_poll_quit(simple_poll);
1106
1793
  }
1107
1794
  errno = old_errno;
1108
1795
}
1109
1796
 
 
1797
__attribute__((nonnull, warn_unused_result))
1110
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1111
1799
  int ret;
 
1800
  int old_errno;
1112
1801
  
1113
1802
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1114
1803
  if(s < 0){
 
1804
    old_errno = errno;
1115
1805
    perror_plus("socket");
 
1806
    errno = old_errno;
1116
1807
    return false;
1117
1808
  }
1118
 
  strcpy(ifr->ifr_name, ifname);
 
1809
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
 
1810
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1119
1811
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1120
1812
  if(ret == -1){
1121
1813
    if(debug){
 
1814
      old_errno = errno;
1122
1815
      perror_plus("ioctl SIOCGIFFLAGS");
 
1816
      errno = old_errno;
 
1817
    }
 
1818
    if((close(s) == -1) and debug){
 
1819
      old_errno = errno;
 
1820
      perror_plus("close");
 
1821
      errno = old_errno;
1123
1822
    }
1124
1823
    return false;
1125
1824
  }
 
1825
  if((close(s) == -1) and debug){
 
1826
    old_errno = errno;
 
1827
    perror_plus("close");
 
1828
    errno = old_errno;
 
1829
  }
1126
1830
  return true;
1127
1831
}
1128
1832
 
 
1833
__attribute__((nonnull, warn_unused_result))
1129
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1130
1835
  
1131
1836
  /* Reject the loopback device */
1173
1878
 * corresponds to an acceptable network device.
1174
1879
 * (This function is passed to scandir(3) as a filter function.)
1175
1880
 */
 
1881
__attribute__((nonnull, warn_unused_result))
1176
1882
int good_interface(const struct dirent *if_entry){
1177
1883
  if(if_entry->d_name[0] == '.'){
1178
1884
    return 0;
1194
1900
}
1195
1901
 
1196
1902
/* 
1197
 
 * This function determines if a directory entry in /sys/class/net
1198
 
 * corresponds to an acceptable network device which is up.
1199
 
 * (This function is passed to scandir(3) as a filter function.)
1200
 
 */
1201
 
int up_interface(const struct dirent *if_entry){
1202
 
  if(if_entry->d_name[0] == '.'){
1203
 
    return 0;
1204
 
  }
1205
 
  
1206
 
  struct ifreq ifr;
1207
 
  if(not get_flags(if_entry->d_name, &ifr)){
1208
 
    if(debug){
1209
 
      fprintf_plus(stderr, "Failed to get flags for interface "
1210
 
                   "\"%s\"\n", if_entry->d_name);
1211
 
    }
1212
 
    return 0;
1213
 
  }
1214
 
  
1215
 
  /* Reject down interfaces */
1216
 
  if(not (ifr.ifr_flags & IFF_UP)){
1217
 
    if(debug){
1218
 
      fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1219
 
                   if_entry->d_name);
1220
 
    }
1221
 
    return 0;
1222
 
  }
1223
 
  
1224
 
  /* Reject non-running interfaces */
1225
 
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1226
 
    if(debug){
1227
 
      fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1228
 
                   if_entry->d_name);
1229
 
    }
1230
 
    return 0;
1231
 
  }
1232
 
  
1233
 
  if(not good_flags(if_entry->d_name, &ifr)){
1234
 
    return 0;
1235
 
  }
1236
 
  return 1;
1237
 
}
1238
 
 
 
1903
 * This function determines if a network interface is up.
 
1904
 */
 
1905
__attribute__((nonnull, warn_unused_result))
 
1906
bool interface_is_up(const char *interface){
 
1907
  struct ifreq ifr;
 
1908
  if(not get_flags(interface, &ifr)){
 
1909
    if(debug){
 
1910
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1911
                   "\"%s\"\n", interface);
 
1912
    }
 
1913
    return false;
 
1914
  }
 
1915
  
 
1916
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1917
}
 
1918
 
 
1919
/* 
 
1920
 * This function determines if a network interface is running
 
1921
 */
 
1922
__attribute__((nonnull, warn_unused_result))
 
1923
bool interface_is_running(const char *interface){
 
1924
  struct ifreq ifr;
 
1925
  if(not get_flags(interface, &ifr)){
 
1926
    if(debug){
 
1927
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1928
                   "\"%s\"\n", interface);
 
1929
    }
 
1930
    return false;
 
1931
  }
 
1932
  
 
1933
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1934
}
 
1935
 
 
1936
__attribute__((nonnull, pure, warn_unused_result))
1239
1937
int notdotentries(const struct dirent *direntry){
1240
1938
  /* Skip "." and ".." */
1241
1939
  if(direntry->d_name[0] == '.'
1248
1946
}
1249
1947
 
1250
1948
/* Is this directory entry a runnable program? */
 
1949
__attribute__((nonnull, warn_unused_result))
1251
1950
int runnable_hook(const struct dirent *direntry){
1252
1951
  int ret;
1253
1952
  size_t sret;
1261
1960
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1262
1961
                "abcdefghijklmnopqrstuvwxyz"
1263
1962
                "0123456789"
1264
 
                "_-");
 
1963
                "_.-");
1265
1964
  if((direntry->d_name)[sret] != '\0'){
1266
1965
    /* Contains non-allowed characters */
1267
1966
    if(debug){
1271
1970
    return 0;
1272
1971
  }
1273
1972
  
1274
 
  char *fullname = NULL;
1275
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1276
 
  if(ret < 0){
1277
 
    perror_plus("asprintf");
1278
 
    return 0;
1279
 
  }
1280
 
  
1281
 
  ret = stat(fullname, &st);
 
1973
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1282
1974
  if(ret == -1){
1283
1975
    if(debug){
1284
1976
      perror_plus("Could not stat hook");
1308
2000
  return 1;
1309
2001
}
1310
2002
 
1311
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
2003
__attribute__((nonnull, warn_unused_result))
 
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
2005
                            mandos_context *mc){
1312
2006
  int ret;
1313
2007
  struct timespec now;
1314
2008
  struct timespec waited_time;
1315
2009
  intmax_t block_time;
1316
2010
  
1317
2011
  while(true){
1318
 
    if(mc.current_server == NULL){
1319
 
      if (debug){
 
2012
    if(mc->current_server == NULL){
 
2013
      if(debug){
1320
2014
        fprintf_plus(stderr, "Wait until first server is found."
1321
2015
                     " No timeout!\n");
1322
2016
      }
1323
2017
      ret = avahi_simple_poll_iterate(s, -1);
1324
2018
    } else {
1325
 
      if (debug){
 
2019
      if(debug){
1326
2020
        fprintf_plus(stderr, "Check current_server if we should run"
1327
2021
                     " it, or wait\n");
1328
2022
      }
1335
2029
      /* Calculating in ms how long time between now and server
1336
2030
         who we visted longest time ago. Now - last seen.  */
1337
2031
      waited_time.tv_sec = (now.tv_sec
1338
 
                            - mc.current_server->last_seen.tv_sec);
 
2032
                            - mc->current_server->last_seen.tv_sec);
1339
2033
      waited_time.tv_nsec = (now.tv_nsec
1340
 
                             - mc.current_server->last_seen.tv_nsec);
 
2034
                             - mc->current_server->last_seen.tv_nsec);
1341
2035
      /* total time is 10s/10,000ms.
1342
2036
         Converting to s from ms by dividing by 1,000,
1343
2037
         and ns to ms by dividing by 1,000,000. */
1345
2039
                     - ((intmax_t)waited_time.tv_sec * 1000))
1346
2040
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1347
2041
      
1348
 
      if (debug){
 
2042
      if(debug){
1349
2043
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1350
2044
                     block_time);
1351
2045
      }
1352
2046
      
1353
2047
      if(block_time <= 0){
1354
 
        ret = start_mandos_communication(mc.current_server->ip,
1355
 
                                         mc.current_server->port,
1356
 
                                         mc.current_server->if_index,
1357
 
                                         mc.current_server->af);
 
2048
        ret = start_mandos_communication(mc->current_server->ip,
 
2049
                                         mc->current_server->port,
 
2050
                                         mc->current_server->if_index,
 
2051
                                         mc->current_server->af, mc);
1358
2052
        if(ret == 0){
1359
 
          avahi_simple_poll_quit(mc.simple_poll);
 
2053
          avahi_simple_poll_quit(s);
1360
2054
          return 0;
1361
2055
        }
1362
2056
        ret = clock_gettime(CLOCK_MONOTONIC,
1363
 
                            &mc.current_server->last_seen);
 
2057
                            &mc->current_server->last_seen);
1364
2058
        if(ret == -1){
1365
2059
          perror_plus("clock_gettime");
1366
2060
          return -1;
1367
2061
        }
1368
 
        mc.current_server = mc.current_server->next;
 
2062
        mc->current_server = mc->current_server->next;
1369
2063
        block_time = 0;         /* Call avahi to find new Mandos
1370
2064
                                   servers, but don't block */
1371
2065
      }
1373
2067
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1374
2068
    }
1375
2069
    if(ret != 0){
1376
 
      if (ret > 0 or errno != EINTR){
 
2070
      if(ret > 0 or errno != EINTR){
1377
2071
        return (ret != 1) ? ret : 0;
1378
2072
      }
1379
2073
    }
1380
2074
  }
1381
2075
}
1382
2076
 
1383
 
bool run_network_hooks(const char *mode, const char *interface,
 
2077
__attribute__((nonnull))
 
2078
void run_network_hooks(const char *mode, const char *interface,
1384
2079
                       const float delay){
1385
 
  struct dirent **direntries;
1386
 
  struct dirent *direntry;
1387
 
  int ret;
1388
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1389
 
                         alphasort);
 
2080
  struct dirent **direntries = NULL;
 
2081
  if(hookdir_fd == -1){
 
2082
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
2083
                      | O_CLOEXEC);
 
2084
    if(hookdir_fd == -1){
 
2085
      if(errno == ENOENT){
 
2086
        if(debug){
 
2087
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
2088
                       " found\n", hookdir);
 
2089
        }
 
2090
      } else {
 
2091
        perror_plus("open");
 
2092
      }
 
2093
      return;
 
2094
    }
 
2095
  }
 
2096
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
2097
  if(devnull == -1){
 
2098
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
2099
    return;
 
2100
  }
 
2101
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
2102
                           runnable_hook, alphasort);
1390
2103
  if(numhooks == -1){
1391
2104
    perror_plus("scandir");
1392
 
  } else {
1393
 
    int devnull = open("/dev/null", O_RDONLY);
1394
 
    for(int i = 0; i < numhooks; i++){
1395
 
      direntry = direntries[i];
1396
 
      char *fullname = NULL;
1397
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1398
 
      if(ret < 0){
 
2105
    close(devnull);
 
2106
    return;
 
2107
  }
 
2108
  struct dirent *direntry;
 
2109
  int ret;
 
2110
  for(int i = 0; i < numhooks; i++){
 
2111
    direntry = direntries[i];
 
2112
    if(debug){
 
2113
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
2114
                   direntry->d_name);
 
2115
    }
 
2116
    pid_t hook_pid = fork();
 
2117
    if(hook_pid == 0){
 
2118
      /* Child */
 
2119
      /* Raise privileges */
 
2120
      errno = raise_privileges_permanently();
 
2121
      if(errno != 0){
 
2122
        perror_plus("Failed to raise privileges");
 
2123
        _exit(EX_NOPERM);
 
2124
      }
 
2125
      /* Set group */
 
2126
      errno = 0;
 
2127
      ret = setgid(0);
 
2128
      if(ret == -1){
 
2129
        perror_plus("setgid");
 
2130
        _exit(EX_NOPERM);
 
2131
      }
 
2132
      /* Reset supplementary groups */
 
2133
      errno = 0;
 
2134
      ret = setgroups(0, NULL);
 
2135
      if(ret == -1){
 
2136
        perror_plus("setgroups");
 
2137
        _exit(EX_NOPERM);
 
2138
      }
 
2139
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
2140
      if(ret == -1){
 
2141
        perror_plus("setenv");
 
2142
        _exit(EX_OSERR);
 
2143
      }
 
2144
      ret = setenv("DEVICE", interface, 1);
 
2145
      if(ret == -1){
 
2146
        perror_plus("setenv");
 
2147
        _exit(EX_OSERR);
 
2148
      }
 
2149
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
2150
      if(ret == -1){
 
2151
        perror_plus("setenv");
 
2152
        _exit(EX_OSERR);
 
2153
      }
 
2154
      ret = setenv("MODE", mode, 1);
 
2155
      if(ret == -1){
 
2156
        perror_plus("setenv");
 
2157
        _exit(EX_OSERR);
 
2158
      }
 
2159
      char *delaystring;
 
2160
      ret = asprintf(&delaystring, "%f", (double)delay);
 
2161
      if(ret == -1){
1399
2162
        perror_plus("asprintf");
1400
 
        continue;
1401
 
      }
1402
 
      if(debug){
1403
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1404
 
                     direntry->d_name);
1405
 
      }
1406
 
      pid_t hook_pid = fork();
1407
 
      if(hook_pid == 0){
1408
 
        /* Child */
1409
 
        dup2(devnull, STDIN_FILENO);
1410
 
        close(devnull);
1411
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1412
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1413
 
        if(ret == -1){
1414
 
          perror_plus("setenv");
1415
 
          _exit(EX_OSERR);
1416
 
        }
1417
 
        ret = setenv("DEVICE", interface, 1);
1418
 
        if(ret == -1){
1419
 
          perror_plus("setenv");
1420
 
          _exit(EX_OSERR);
1421
 
        }
1422
 
        ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1423
 
        if(ret == -1){
1424
 
          perror_plus("setenv");
1425
 
          _exit(EX_OSERR);
1426
 
        }
1427
 
        ret = setenv("MODE", mode, 1);
1428
 
        if(ret == -1){
1429
 
          perror_plus("setenv");
1430
 
          _exit(EX_OSERR);
1431
 
        }
1432
 
        char *delaystring;
1433
 
        ret = asprintf(&delaystring, "%f", delay);
1434
 
        if(ret == -1){
1435
 
          perror_plus("asprintf");
1436
 
          _exit(EX_OSERR);
1437
 
        }
1438
 
        ret = setenv("DELAY", delaystring, 1);
1439
 
        if(ret == -1){
1440
 
          free(delaystring);
1441
 
          perror_plus("setenv");
1442
 
          _exit(EX_OSERR);
1443
 
        }
 
2163
        _exit(EX_OSERR);
 
2164
      }
 
2165
      ret = setenv("DELAY", delaystring, 1);
 
2166
      if(ret == -1){
1444
2167
        free(delaystring);
1445
 
        ret = execl(fullname, direntry->d_name, mode, NULL);
1446
 
        perror_plus("execl");
1447
 
      } else {
1448
 
        int status;
1449
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1450
 
          perror_plus("waitpid");
1451
 
          free(fullname);
1452
 
          continue;
1453
 
        }
1454
 
        if(WIFEXITED(status)){
1455
 
          if(WEXITSTATUS(status) != 0){
1456
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1457
 
                         " with status %d\n", direntry->d_name,
1458
 
                         WEXITSTATUS(status));
1459
 
            free(fullname);
1460
 
            continue;
1461
 
          }
1462
 
        } else if(WIFSIGNALED(status)){
1463
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1464
 
                       " signal %d\n", direntry->d_name,
1465
 
                       WTERMSIG(status));
1466
 
          free(fullname);
1467
 
          continue;
1468
 
        } else {
1469
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1470
 
                       " crashed\n", direntry->d_name);
1471
 
          free(fullname);
1472
 
          continue;
1473
 
        }
1474
 
      }
1475
 
      free(fullname);
1476
 
      if(debug){
1477
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1478
 
                     direntry->d_name);
1479
 
      }
1480
 
    }
1481
 
    close(devnull);
1482
 
  }
1483
 
  return true;
 
2168
        perror_plus("setenv");
 
2169
        _exit(EX_OSERR);
 
2170
      }
 
2171
      free(delaystring);
 
2172
      if(connect_to != NULL){
 
2173
        ret = setenv("CONNECT", connect_to, 1);
 
2174
        if(ret == -1){
 
2175
          perror_plus("setenv");
 
2176
          _exit(EX_OSERR);
 
2177
        }
 
2178
      }
 
2179
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2180
                                                   direntry->d_name,
 
2181
                                                   O_RDONLY));
 
2182
      if(hook_fd == -1){
 
2183
        perror_plus("openat");
 
2184
        _exit(EXIT_FAILURE);
 
2185
      }
 
2186
      if(close(hookdir_fd) == -1){
 
2187
        perror_plus("close");
 
2188
        _exit(EXIT_FAILURE);
 
2189
      }
 
2190
      ret = dup2(devnull, STDIN_FILENO);
 
2191
      if(ret == -1){
 
2192
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
2193
        _exit(EX_OSERR);
 
2194
      }
 
2195
      ret = close(devnull);
 
2196
      if(ret == -1){
 
2197
        perror_plus("close");
 
2198
        _exit(EX_OSERR);
 
2199
      }
 
2200
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
2201
      if(ret == -1){
 
2202
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
2203
        _exit(EX_OSERR);
 
2204
      }
 
2205
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
2206
                 environ) == -1){
 
2207
        perror_plus("fexecve");
 
2208
        _exit(EXIT_FAILURE);
 
2209
      }
 
2210
    } else {
 
2211
      if(hook_pid == -1){
 
2212
        perror_plus("fork");
 
2213
        free(direntry);
 
2214
        continue;
 
2215
      }
 
2216
      int status;
 
2217
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
2218
        perror_plus("waitpid");
 
2219
        free(direntry);
 
2220
        continue;
 
2221
      }
 
2222
      if(WIFEXITED(status)){
 
2223
        if(WEXITSTATUS(status) != 0){
 
2224
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
2225
                       " with status %d\n", direntry->d_name,
 
2226
                       WEXITSTATUS(status));
 
2227
          free(direntry);
 
2228
          continue;
 
2229
        }
 
2230
      } else if(WIFSIGNALED(status)){
 
2231
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
2232
                     " signal %d\n", direntry->d_name,
 
2233
                     WTERMSIG(status));
 
2234
        free(direntry);
 
2235
        continue;
 
2236
      } else {
 
2237
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
2238
                     " crashed\n", direntry->d_name);
 
2239
        free(direntry);
 
2240
        continue;
 
2241
      }
 
2242
    }
 
2243
    if(debug){
 
2244
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
2245
                   direntry->d_name);
 
2246
    }
 
2247
    free(direntry);
 
2248
  }
 
2249
  free(direntries);
 
2250
  if(close(hookdir_fd) == -1){
 
2251
    perror_plus("close");
 
2252
  } else {
 
2253
    hookdir_fd = -1;
 
2254
  }
 
2255
  close(devnull);
 
2256
}
 
2257
 
 
2258
__attribute__((nonnull, warn_unused_result))
 
2259
int bring_up_interface(const char *const interface,
 
2260
                       const float delay){
 
2261
  int old_errno = errno;
 
2262
  int ret;
 
2263
  struct ifreq network;
 
2264
  unsigned int if_index = if_nametoindex(interface);
 
2265
  if(if_index == 0){
 
2266
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
2267
    errno = old_errno;
 
2268
    return ENXIO;
 
2269
  }
 
2270
  
 
2271
  if(quit_now){
 
2272
    errno = old_errno;
 
2273
    return EINTR;
 
2274
  }
 
2275
  
 
2276
  if(not interface_is_up(interface)){
 
2277
    int ret_errno = 0;
 
2278
    int ioctl_errno = 0;
 
2279
    if(not get_flags(interface, &network)){
 
2280
      ret_errno = errno;
 
2281
      fprintf_plus(stderr, "Failed to get flags for interface "
 
2282
                   "\"%s\"\n", interface);
 
2283
      errno = old_errno;
 
2284
      return ret_errno;
 
2285
    }
 
2286
    network.ifr_flags |= IFF_UP; /* set flag */
 
2287
    
 
2288
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2289
    if(sd == -1){
 
2290
      ret_errno = errno;
 
2291
      perror_plus("socket");
 
2292
      errno = old_errno;
 
2293
      return ret_errno;
 
2294
    }
 
2295
    
 
2296
    if(quit_now){
 
2297
      ret = close(sd);
 
2298
      if(ret == -1){
 
2299
        perror_plus("close");
 
2300
      }
 
2301
      errno = old_errno;
 
2302
      return EINTR;
 
2303
    }
 
2304
    
 
2305
    if(debug){
 
2306
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
2307
                   interface);
 
2308
    }
 
2309
    
 
2310
    /* Raise privileges */
 
2311
    ret_errno = raise_privileges();
 
2312
    if(ret_errno != 0){
 
2313
      errno = ret_errno;
 
2314
      perror_plus("Failed to raise privileges");
 
2315
    }
 
2316
    
 
2317
#ifdef __linux__
 
2318
    int ret_linux;
 
2319
    bool restore_loglevel = false;
 
2320
    if(ret_errno == 0){
 
2321
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
2322
         messages about the network interface to mess up the prompt */
 
2323
      ret_linux = klogctl(8, NULL, 5);
 
2324
      if(ret_linux == -1){
 
2325
        perror_plus("klogctl");
 
2326
      } else {
 
2327
        restore_loglevel = true;
 
2328
      }
 
2329
    }
 
2330
#endif  /* __linux__ */
 
2331
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2332
    ioctl_errno = errno;
 
2333
#ifdef __linux__
 
2334
    if(restore_loglevel){
 
2335
      ret_linux = klogctl(7, NULL, 0);
 
2336
      if(ret_linux == -1){
 
2337
        perror_plus("klogctl");
 
2338
      }
 
2339
    }
 
2340
#endif  /* __linux__ */
 
2341
    
 
2342
    /* If raise_privileges() succeeded above */
 
2343
    if(ret_errno == 0){
 
2344
      /* Lower privileges */
 
2345
      ret_errno = lower_privileges();
 
2346
      if(ret_errno != 0){
 
2347
        errno = ret_errno;
 
2348
        perror_plus("Failed to lower privileges");
 
2349
      }
 
2350
    }
 
2351
    
 
2352
    /* Close the socket */
 
2353
    ret = close(sd);
 
2354
    if(ret == -1){
 
2355
      perror_plus("close");
 
2356
    }
 
2357
    
 
2358
    if(ret_setflags == -1){
 
2359
      errno = ioctl_errno;
 
2360
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
2361
      errno = old_errno;
 
2362
      return ioctl_errno;
 
2363
    }
 
2364
  } else if(debug){
 
2365
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
2366
                 interface);
 
2367
  }
 
2368
  
 
2369
  /* Sleep checking until interface is running.
 
2370
     Check every 0.25s, up to total time of delay */
 
2371
  for(int i = 0; i < delay * 4; i++){
 
2372
    if(interface_is_running(interface)){
 
2373
      break;
 
2374
    }
 
2375
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
2376
    ret = nanosleep(&sleeptime, NULL);
 
2377
    if(ret == -1 and errno != EINTR){
 
2378
      perror_plus("nanosleep");
 
2379
    }
 
2380
  }
 
2381
  
 
2382
  errno = old_errno;
 
2383
  return 0;
 
2384
}
 
2385
 
 
2386
__attribute__((nonnull, warn_unused_result))
 
2387
int take_down_interface(const char *const interface){
 
2388
  int old_errno = errno;
 
2389
  struct ifreq network;
 
2390
  unsigned int if_index = if_nametoindex(interface);
 
2391
  if(if_index == 0){
 
2392
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
2393
    errno = old_errno;
 
2394
    return ENXIO;
 
2395
  }
 
2396
  if(interface_is_up(interface)){
 
2397
    int ret_errno = 0;
 
2398
    int ioctl_errno = 0;
 
2399
    if(not get_flags(interface, &network) and debug){
 
2400
      ret_errno = errno;
 
2401
      fprintf_plus(stderr, "Failed to get flags for interface "
 
2402
                   "\"%s\"\n", interface);
 
2403
      errno = old_errno;
 
2404
      return ret_errno;
 
2405
    }
 
2406
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
2407
    
 
2408
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2409
    if(sd == -1){
 
2410
      ret_errno = errno;
 
2411
      perror_plus("socket");
 
2412
      errno = old_errno;
 
2413
      return ret_errno;
 
2414
    }
 
2415
    
 
2416
    if(debug){
 
2417
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
2418
                   interface);
 
2419
    }
 
2420
    
 
2421
    /* Raise privileges */
 
2422
    ret_errno = raise_privileges();
 
2423
    if(ret_errno != 0){
 
2424
      errno = ret_errno;
 
2425
      perror_plus("Failed to raise privileges");
 
2426
    }
 
2427
    
 
2428
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2429
    ioctl_errno = errno;
 
2430
    
 
2431
    /* If raise_privileges() succeeded above */
 
2432
    if(ret_errno == 0){
 
2433
      /* Lower privileges */
 
2434
      ret_errno = lower_privileges();
 
2435
      if(ret_errno != 0){
 
2436
        errno = ret_errno;
 
2437
        perror_plus("Failed to lower privileges");
 
2438
      }
 
2439
    }
 
2440
    
 
2441
    /* Close the socket */
 
2442
    int ret = close(sd);
 
2443
    if(ret == -1){
 
2444
      perror_plus("close");
 
2445
    }
 
2446
    
 
2447
    if(ret_setflags == -1){
 
2448
      errno = ioctl_errno;
 
2449
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
2450
      errno = old_errno;
 
2451
      return ioctl_errno;
 
2452
    }
 
2453
  } else if(debug){
 
2454
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
2455
                 interface);
 
2456
  }
 
2457
  
 
2458
  errno = old_errno;
 
2459
  return 0;
1484
2460
}
1485
2461
 
1486
2462
int main(int argc, char *argv[]){
 
2463
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2464
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2465
                        .priority = "SECURE128:!CTYPE-X.509"
 
2466
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
 
2467
                        ":%PROFILE_ULTRA",
 
2468
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2469
                        .priority = "SECURE256:!CTYPE-X.509"
 
2470
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2471
#else
 
2472
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
2473
#endif
 
2474
                        .current_server = NULL, .interfaces = NULL,
 
2475
                        .interfaces_size = 0 };
1487
2476
  AvahiSServiceBrowser *sb = NULL;
1488
 
  int error;
 
2477
  error_t ret_errno;
1489
2478
  int ret;
1490
2479
  intmax_t tmpmax;
1491
2480
  char *tmp;
1492
2481
  int exitcode = EXIT_SUCCESS;
1493
 
  const char *interface = "";
1494
 
  struct ifreq network;
1495
 
  int sd = -1;
1496
 
  bool take_down_interface = false;
1497
 
  uid_t uid;
1498
 
  gid_t gid;
1499
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1500
 
  bool tempdir_created = false;
 
2482
  char *interfaces_to_take_down = NULL;
 
2483
  size_t interfaces_to_take_down_size = 0;
 
2484
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2485
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2486
  char *tempdir = NULL;
1501
2487
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1502
2488
  const char *seckey = PATHDIR "/" SECKEY;
1503
2489
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2490
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2491
  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
 
2492
  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
 
2493
#endif
 
2494
  const char *dh_params_file = NULL;
 
2495
  char *interfaces_hooks = NULL;
1504
2496
  
1505
2497
  bool gnutls_initialized = false;
1506
2498
  bool gpgme_initialized = false;
1552
2544
      { .name = "pubkey", .key = 'p',
1553
2545
        .arg = "FILE",
1554
2546
        .doc = "OpenPGP public key file base name",
1555
 
        .group = 2 },
 
2547
        .group = 1 },
 
2548
      { .name = "tls-privkey", .key = 't',
 
2549
        .arg = "FILE",
 
2550
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2551
        .doc = "TLS private key file base name",
 
2552
#else
 
2553
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2554
#endif
 
2555
        .group = 1 },
 
2556
      { .name = "tls-pubkey", .key = 'T',
 
2557
        .arg = "FILE",
 
2558
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2559
        .doc = "TLS public key file base name",
 
2560
#else
 
2561
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2562
#endif
 
2563
        .group = 1 },
1556
2564
      { .name = "dh-bits", .key = 129,
1557
2565
        .arg = "BITS",
1558
2566
        .doc = "Bit length of the prime number used in the"
1559
2567
        " Diffie-Hellman key exchange",
1560
2568
        .group = 2 },
 
2569
      { .name = "dh-params", .key = 134,
 
2570
        .arg = "FILE",
 
2571
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
 
2572
        " for the Diffie-Hellman key exchange",
 
2573
        .group = 2 },
1561
2574
      { .name = "priority", .key = 130,
1562
2575
        .arg = "STRING",
1563
2576
        .doc = "GnuTLS priority string for the TLS handshake",
1568
2581
        .group = 2 },
1569
2582
      { .name = "retry", .key = 132,
1570
2583
        .arg = "SECONDS",
1571
 
        .doc = "Retry interval used when denied by the mandos server",
 
2584
        .doc = "Retry interval used when denied by the Mandos server",
1572
2585
        .group = 2 },
1573
2586
      { .name = "network-hook-dir", .key = 133,
1574
2587
        .arg = "DIR",
1597
2610
        connect_to = arg;
1598
2611
        break;
1599
2612
      case 'i':                 /* --interface */
1600
 
        interface = arg;
 
2613
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2614
                                 arg, (int)',');
 
2615
        if(ret_errno != 0){
 
2616
          argp_error(state, "%s", strerror(ret_errno));
 
2617
        }
1601
2618
        break;
1602
2619
      case 's':                 /* --seckey */
1603
2620
        seckey = arg;
1605
2622
      case 'p':                 /* --pubkey */
1606
2623
        pubkey = arg;
1607
2624
        break;
 
2625
      case 't':                 /* --tls-privkey */
 
2626
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2627
        tls_privkey = arg;
 
2628
#endif
 
2629
        break;
 
2630
      case 'T':                 /* --tls-pubkey */
 
2631
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2632
        tls_pubkey = arg;
 
2633
#endif
 
2634
        break;
1608
2635
      case 129:                 /* --dh-bits */
1609
2636
        errno = 0;
1610
2637
        tmpmax = strtoimax(arg, &tmp, 10);
1614
2641
        }
1615
2642
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1616
2643
        break;
 
2644
      case 134:                 /* --dh-params */
 
2645
        dh_params_file = arg;
 
2646
        break;
1617
2647
      case 130:                 /* --priority */
1618
2648
        mc.priority = arg;
1619
2649
        break;
1642
2672
        argp_state_help(state, state->out_stream,
1643
2673
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1644
2674
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
2675
        __builtin_unreachable();
1645
2676
      case -3:                  /* --usage */
1646
2677
        argp_state_help(state, state->out_stream,
1647
2678
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
2679
        __builtin_unreachable();
1648
2680
      case 'V':                 /* --version */
1649
 
        fprintf_plus(state->out_stream,
1650
 
                     "Mandos plugin mandos-client: ");
1651
2681
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1652
2682
        exit(argp_err_exit_status);
1653
2683
        break;
1661
2691
                         .args_doc = "",
1662
2692
                         .doc = "Mandos client -- Get and decrypt"
1663
2693
                         " passwords from a Mandos server" };
1664
 
    ret = argp_parse(&argp, argc, argv,
1665
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1666
 
    switch(ret){
 
2694
    ret_errno = argp_parse(&argp, argc, argv,
 
2695
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2696
    switch(ret_errno){
1667
2697
    case 0:
1668
2698
      break;
1669
2699
    case ENOMEM:
1670
2700
    default:
1671
 
      errno = ret;
 
2701
      errno = ret_errno;
1672
2702
      perror_plus("argp_parse");
1673
2703
      exitcode = EX_OSERR;
1674
2704
      goto end;
1677
2707
      goto end;
1678
2708
    }
1679
2709
  }
1680
 
    
1681
 
  if(getuid() == 0){
 
2710
  
 
2711
  {
1682
2712
    /* Work around Debian bug #633582:
1683
 
       <http://bugs.debian.org/633582> */
1684
 
    struct stat st;
1685
 
    
1686
 
    /* Re-raise priviliges */
1687
 
    errno = 0;
1688
 
    ret = seteuid(0);
1689
 
    if(ret == -1){
1690
 
      perror_plus("seteuid");
1691
 
    }
1692
 
    
1693
 
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1694
 
      int seckey_fd = open(seckey, O_RDONLY);
1695
 
      if(seckey_fd == -1){
1696
 
        perror_plus("open");
1697
 
      } else {
1698
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1699
 
        if(ret == -1){
1700
 
          perror_plus("fstat");
1701
 
        } else {
1702
 
          if(S_ISREG(st.st_mode)
1703
 
             and st.st_uid == 0 and st.st_gid == 0){
1704
 
            ret = fchown(seckey_fd, uid, gid);
1705
 
            if(ret == -1){
1706
 
              perror_plus("fchown");
1707
 
            }
1708
 
          }
1709
 
        }
1710
 
        TEMP_FAILURE_RETRY(close(seckey_fd));
1711
 
      }
1712
 
    }
1713
 
    
1714
 
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1715
 
      int pubkey_fd = open(pubkey, O_RDONLY);
1716
 
      if(pubkey_fd == -1){
1717
 
        perror_plus("open");
1718
 
      } else {
1719
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1720
 
        if(ret == -1){
1721
 
          perror_plus("fstat");
1722
 
        } else {
1723
 
          if(S_ISREG(st.st_mode)
1724
 
             and st.st_uid == 0 and st.st_gid == 0){
1725
 
            ret = fchown(pubkey_fd, uid, gid);
1726
 
            if(ret == -1){
1727
 
              perror_plus("fchown");
1728
 
            }
1729
 
          }
1730
 
        }
1731
 
        TEMP_FAILURE_RETRY(close(pubkey_fd));
1732
 
      }
1733
 
    }
1734
 
    
1735
 
    /* Lower privileges */
1736
 
    errno = 0;
1737
 
    ret = seteuid(uid);
1738
 
    if(ret == -1){
1739
 
      perror_plus("seteuid");
 
2713
       <https://bugs.debian.org/633582> */
 
2714
    
 
2715
    /* Re-raise privileges */
 
2716
    ret = raise_privileges();
 
2717
    if(ret != 0){
 
2718
      errno = ret;
 
2719
      perror_plus("Failed to raise privileges");
 
2720
    } else {
 
2721
      struct stat st;
 
2722
      
 
2723
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
2724
        int seckey_fd = open(seckey, O_RDONLY);
 
2725
        if(seckey_fd == -1){
 
2726
          perror_plus("open");
 
2727
        } else {
 
2728
          ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
2729
          if(ret == -1){
 
2730
            perror_plus("fstat");
 
2731
          } else {
 
2732
            if(S_ISREG(st.st_mode)
 
2733
               and st.st_uid == 0 and st.st_gid == 0){
 
2734
              ret = fchown(seckey_fd, uid, gid);
 
2735
              if(ret == -1){
 
2736
                perror_plus("fchown");
 
2737
              }
 
2738
            }
 
2739
          }
 
2740
          close(seckey_fd);
 
2741
        }
 
2742
      }
 
2743
      
 
2744
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
2745
        int pubkey_fd = open(pubkey, O_RDONLY);
 
2746
        if(pubkey_fd == -1){
 
2747
          perror_plus("open");
 
2748
        } else {
 
2749
          ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
2750
          if(ret == -1){
 
2751
            perror_plus("fstat");
 
2752
          } else {
 
2753
            if(S_ISREG(st.st_mode)
 
2754
               and st.st_uid == 0 and st.st_gid == 0){
 
2755
              ret = fchown(pubkey_fd, uid, gid);
 
2756
              if(ret == -1){
 
2757
                perror_plus("fchown");
 
2758
              }
 
2759
            }
 
2760
          }
 
2761
          close(pubkey_fd);
 
2762
        }
 
2763
      }
 
2764
      
 
2765
      if(dh_params_file != NULL
 
2766
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2767
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2768
        if(dhparams_fd == -1){
 
2769
          perror_plus("open");
 
2770
        } else {
 
2771
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2772
          if(ret == -1){
 
2773
            perror_plus("fstat");
 
2774
          } else {
 
2775
            if(S_ISREG(st.st_mode)
 
2776
               and st.st_uid == 0 and st.st_gid == 0){
 
2777
              ret = fchown(dhparams_fd, uid, gid);
 
2778
              if(ret == -1){
 
2779
                perror_plus("fchown");
 
2780
              }
 
2781
            }
 
2782
          }
 
2783
          close(dhparams_fd);
 
2784
        }
 
2785
      }
 
2786
      
 
2787
      /* Lower privileges */
 
2788
      ret = lower_privileges();
 
2789
      if(ret != 0){
 
2790
        errno = ret;
 
2791
        perror_plus("Failed to lower privileges");
 
2792
      }
 
2793
    }
 
2794
  }
 
2795
  
 
2796
  /* Remove invalid interface names (except "none") */
 
2797
  {
 
2798
    char *interface = NULL;
 
2799
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2800
                                 interface))){
 
2801
      if(strcmp(interface, "none") != 0
 
2802
         and if_nametoindex(interface) == 0){
 
2803
        if(interface[0] != '\0'){
 
2804
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2805
                       " \"%s\"\n", interface);
 
2806
        }
 
2807
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
 
2808
        interface = NULL;
 
2809
      }
1740
2810
    }
1741
2811
  }
1742
2812
  
1743
2813
  /* Run network hooks */
1744
2814
  {
1745
 
    if(getuid() == 0){
1746
 
      /* Re-raise priviliges */
1747
 
      errno = 0;
1748
 
      ret = seteuid(0);
1749
 
      if(ret == -1){
1750
 
        perror_plus("seteuid");
1751
 
      }
1752
 
    }
1753
 
    if(not run_network_hooks("start", interface, delay)){
1754
 
      goto end;
1755
 
    }
1756
 
    if(getuid() == 0){
1757
 
      /* Lower privileges */
1758
 
      errno = 0;
1759
 
      ret = seteuid(uid);
1760
 
      if(ret == -1){
1761
 
        perror_plus("seteuid");
1762
 
      }
1763
 
    }
 
2815
    if(mc.interfaces != NULL){
 
2816
      interfaces_hooks = malloc(mc.interfaces_size);
 
2817
      if(interfaces_hooks == NULL){
 
2818
        perror_plus("malloc");
 
2819
        goto end;
 
2820
      }
 
2821
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2822
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2823
    }
 
2824
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2825
                      interfaces_hooks : "", delay);
1764
2826
  }
1765
2827
  
1766
2828
  if(not debug){
1767
2829
    avahi_set_log_function(empty_log);
1768
2830
  }
1769
2831
  
1770
 
  if(interface[0] == '\0'){
1771
 
    struct dirent **direntries;
1772
 
    /* First look for interfaces that are up */
1773
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1774
 
                  alphasort);
1775
 
    if(ret == 0){
1776
 
      /* No up interfaces, look for any good interfaces */
1777
 
      free(direntries);
1778
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1779
 
                    alphasort);
1780
 
    }
1781
 
    if(ret >= 1){
1782
 
      /* Pick the first interface returned */
1783
 
      interface = strdup(direntries[0]->d_name);
1784
 
      if(debug){
1785
 
        fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1786
 
      }
1787
 
      if(interface == NULL){
1788
 
        perror_plus("malloc");
1789
 
        free(direntries);
1790
 
        exitcode = EXIT_FAILURE;
1791
 
        goto end;
1792
 
      }
1793
 
      free(direntries);
1794
 
    } else {
1795
 
      free(direntries);
1796
 
      fprintf_plus(stderr, "Could not find a network interface\n");
1797
 
      exitcode = EXIT_FAILURE;
1798
 
      goto end;
1799
 
    }
1800
 
  }
1801
 
  
1802
2832
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1803
2833
     from the signal handler */
1804
2834
  /* Initialize the pseudo-RNG for Avahi */
1805
2835
  srand((unsigned int) time(NULL));
1806
 
  mc.simple_poll = avahi_simple_poll_new();
1807
 
  if(mc.simple_poll == NULL){
 
2836
  simple_poll = avahi_simple_poll_new();
 
2837
  if(simple_poll == NULL){
1808
2838
    fprintf_plus(stderr,
1809
2839
                 "Avahi: Failed to create simple poll object.\n");
1810
2840
    exitcode = EX_UNAVAILABLE;
1874
2904
    }
1875
2905
  }
1876
2906
  
1877
 
  /* If the interface is down, bring it up */
1878
 
  if(strcmp(interface, "none") != 0){
1879
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1880
 
    if(if_index == 0){
1881
 
      fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1882
 
      exitcode = EX_UNAVAILABLE;
1883
 
      goto end;
1884
 
    }
1885
 
    
1886
 
    if(quit_now){
1887
 
      goto end;
1888
 
    }
1889
 
    
1890
 
    /* Re-raise priviliges */
1891
 
    errno = 0;
1892
 
    ret = seteuid(0);
1893
 
    if(ret == -1){
1894
 
      perror_plus("seteuid");
1895
 
    }
1896
 
    
1897
 
#ifdef __linux__
1898
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1899
 
       messages about the network interface to mess up the prompt */
1900
 
    ret = klogctl(8, NULL, 5);
1901
 
    bool restore_loglevel = true;
1902
 
    if(ret == -1){
1903
 
      restore_loglevel = false;
1904
 
      perror_plus("klogctl");
1905
 
    }
1906
 
#endif  /* __linux__ */
1907
 
    
1908
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1909
 
    if(sd < 0){
1910
 
      perror_plus("socket");
1911
 
      exitcode = EX_OSERR;
1912
 
#ifdef __linux__
1913
 
      if(restore_loglevel){
1914
 
        ret = klogctl(7, NULL, 0);
1915
 
        if(ret == -1){
1916
 
          perror_plus("klogctl");
1917
 
        }
1918
 
      }
1919
 
#endif  /* __linux__ */
1920
 
      /* Lower privileges */
1921
 
      errno = 0;
1922
 
      ret = seteuid(uid);
1923
 
      if(ret == -1){
1924
 
        perror_plus("seteuid");
1925
 
      }
1926
 
      goto end;
1927
 
    }
1928
 
    strcpy(network.ifr_name, interface);
1929
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1930
 
    if(ret == -1){
1931
 
      perror_plus("ioctl SIOCGIFFLAGS");
1932
 
#ifdef __linux__
1933
 
      if(restore_loglevel){
1934
 
        ret = klogctl(7, NULL, 0);
1935
 
        if(ret == -1){
1936
 
          perror_plus("klogctl");
1937
 
        }
1938
 
      }
1939
 
#endif  /* __linux__ */
1940
 
      exitcode = EX_OSERR;
1941
 
      /* Lower privileges */
1942
 
      errno = 0;
1943
 
      ret = seteuid(uid);
1944
 
      if(ret == -1){
1945
 
        perror_plus("seteuid");
1946
 
      }
1947
 
      goto end;
1948
 
    }
1949
 
    if((network.ifr_flags & IFF_UP) == 0){
1950
 
      network.ifr_flags |= IFF_UP;
1951
 
      take_down_interface = true;
1952
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1953
 
      if(ret == -1){
1954
 
        take_down_interface = false;
1955
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1956
 
        exitcode = EX_OSERR;
1957
 
#ifdef __linux__
1958
 
        if(restore_loglevel){
1959
 
          ret = klogctl(7, NULL, 0);
1960
 
          if(ret == -1){
1961
 
            perror_plus("klogctl");
 
2907
  /* If no interfaces were specified, make a list */
 
2908
  if(mc.interfaces == NULL){
 
2909
    struct dirent **direntries = NULL;
 
2910
    /* Look for any good interfaces */
 
2911
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2912
                  alphasort);
 
2913
    if(ret >= 1){
 
2914
      /* Add all found interfaces to interfaces list */
 
2915
      for(int i = 0; i < ret; ++i){
 
2916
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2917
                             direntries[i]->d_name);
 
2918
        if(ret_errno != 0){
 
2919
          errno = ret_errno;
 
2920
          perror_plus("argz_add");
 
2921
          free(direntries[i]);
 
2922
          continue;
 
2923
        }
 
2924
        if(debug){
 
2925
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2926
                       direntries[i]->d_name);
 
2927
        }
 
2928
        free(direntries[i]);
 
2929
      }
 
2930
      free(direntries);
 
2931
    } else {
 
2932
      if(ret == 0){
 
2933
        free(direntries);
 
2934
      }
 
2935
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2936
      exitcode = EXIT_FAILURE;
 
2937
      goto end;
 
2938
    }
 
2939
  }
 
2940
  
 
2941
  /* Bring up interfaces which are down, and remove any "none"s */
 
2942
  {
 
2943
    char *interface = NULL;
 
2944
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2945
                                 interface))){
 
2946
      /* If interface name is "none", stop bringing up interfaces.
 
2947
         Also remove all instances of "none" from the list */
 
2948
      if(strcmp(interface, "none") == 0){
 
2949
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2950
                    interface);
 
2951
        interface = NULL;
 
2952
        while((interface = argz_next(mc.interfaces,
 
2953
                                     mc.interfaces_size, interface))){
 
2954
          if(strcmp(interface, "none") == 0){
 
2955
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2956
                        interface);
 
2957
            interface = NULL;
1962
2958
          }
1963
2959
        }
1964
 
#endif  /* __linux__ */
1965
 
        /* Lower privileges */
1966
 
        errno = 0;
1967
 
        ret = seteuid(uid);
1968
 
        if(ret == -1){
1969
 
          perror_plus("seteuid");
1970
 
        }
1971
 
        goto end;
1972
 
      }
1973
 
    }
1974
 
    /* Sleep checking until interface is running.
1975
 
       Check every 0.25s, up to total time of delay */
1976
 
    for(int i=0; i < delay * 4; i++){
1977
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1978
 
      if(ret == -1){
1979
 
        perror_plus("ioctl SIOCGIFFLAGS");
1980
 
      } else if(network.ifr_flags & IFF_RUNNING){
1981
2960
        break;
1982
2961
      }
1983
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1984
 
      ret = nanosleep(&sleeptime, NULL);
1985
 
      if(ret == -1 and errno != EINTR){
1986
 
        perror_plus("nanosleep");
1987
 
      }
1988
 
    }
1989
 
    if(not take_down_interface){
1990
 
      /* We won't need the socket anymore */
1991
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1992
 
      if(ret == -1){
1993
 
        perror_plus("close");
1994
 
      }
1995
 
    }
1996
 
#ifdef __linux__
1997
 
    if(restore_loglevel){
1998
 
      /* Restores kernel loglevel to default */
1999
 
      ret = klogctl(7, NULL, 0);
2000
 
      if(ret == -1){
2001
 
        perror_plus("klogctl");
2002
 
      }
2003
 
    }
2004
 
#endif  /* __linux__ */
2005
 
    /* Lower privileges */
2006
 
    errno = 0;
2007
 
    /* Lower privileges */
2008
 
    ret = seteuid(uid);
2009
 
    if(ret == -1){
2010
 
      perror_plus("seteuid");
2011
 
    }
 
2962
      bool interface_was_up = interface_is_up(interface);
 
2963
      errno = bring_up_interface(interface, delay);
 
2964
      if(not interface_was_up){
 
2965
        if(errno != 0){
 
2966
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2967
                       " %s\n", interface, strerror(errno));
 
2968
        } else {
 
2969
          errno = argz_add(&interfaces_to_take_down,
 
2970
                           &interfaces_to_take_down_size,
 
2971
                           interface);
 
2972
          if(errno != 0){
 
2973
            perror_plus("argz_add");
 
2974
          }
 
2975
        }
 
2976
      }
 
2977
    }
 
2978
    if(debug and (interfaces_to_take_down == NULL)){
 
2979
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2980
    }
 
2981
  }
 
2982
  
 
2983
  /* If we only got one interface, explicitly use only that one */
 
2984
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2985
    if(debug){
 
2986
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2987
                   mc.interfaces);
 
2988
    }
 
2989
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2012
2990
  }
2013
2991
  
2014
2992
  if(quit_now){
2015
2993
    goto end;
2016
2994
  }
2017
2995
  
2018
 
  ret = init_gnutls_global(pubkey, seckey);
 
2996
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2997
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
 
2998
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2999
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
 
3000
#else
 
3001
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
3002
#endif
2019
3003
  if(ret == -1){
2020
3004
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2021
3005
    exitcode = EX_UNAVAILABLE;
2028
3012
    goto end;
2029
3013
  }
2030
3014
  
2031
 
  if(mkdtemp(tempdir) == NULL){
 
3015
  /* Try /run/tmp before /tmp */
 
3016
  tempdir = mkdtemp(run_tempdir);
 
3017
  if(tempdir == NULL and errno == ENOENT){
 
3018
      if(debug){
 
3019
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
3020
                     run_tempdir, old_tempdir);
 
3021
      }
 
3022
      tempdir = mkdtemp(old_tempdir);
 
3023
  }
 
3024
  if(tempdir == NULL){
2032
3025
    perror_plus("mkdtemp");
2033
3026
    goto end;
2034
3027
  }
2035
 
  tempdir_created = true;
2036
3028
  
2037
3029
  if(quit_now){
2038
3030
    goto end;
2039
3031
  }
2040
3032
  
2041
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
3033
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2042
3034
    fprintf_plus(stderr, "init_gpgme failed\n");
2043
3035
    exitcode = EX_UNAVAILABLE;
2044
3036
    goto end;
2054
3046
    /* Connect directly, do not use Zeroconf */
2055
3047
    /* (Mainly meant for debugging) */
2056
3048
    char *address = strrchr(connect_to, ':');
 
3049
    
2057
3050
    if(address == NULL){
2058
3051
      fprintf_plus(stderr, "No colon in address\n");
2059
3052
      exitcode = EX_USAGE;
2064
3057
      goto end;
2065
3058
    }
2066
3059
    
2067
 
    uint16_t port;
 
3060
    in_port_t port;
2068
3061
    errno = 0;
2069
3062
    tmpmax = strtoimax(address+1, &tmp, 10);
2070
3063
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
2071
 
       or tmpmax != (uint16_t)tmpmax){
 
3064
       or tmpmax != (in_port_t)tmpmax){
2072
3065
      fprintf_plus(stderr, "Bad port number\n");
2073
3066
      exitcode = EX_USAGE;
2074
3067
      goto end;
2075
3068
    }
2076
 
  
 
3069
    
2077
3070
    if(quit_now){
2078
3071
      goto end;
2079
3072
    }
2080
3073
    
2081
 
    port = (uint16_t)tmpmax;
 
3074
    port = (in_port_t)tmpmax;
2082
3075
    *address = '\0';
2083
3076
    /* Colon in address indicates IPv6 */
2084
3077
    int af;
2100
3093
    }
2101
3094
    
2102
3095
    while(not quit_now){
2103
 
      ret = start_mandos_communication(address, port, if_index, af);
 
3096
      ret = start_mandos_communication(address, port, if_index, af,
 
3097
                                       &mc);
2104
3098
      if(quit_now or ret == 0){
2105
3099
        break;
2106
3100
      }
2108
3102
        fprintf_plus(stderr, "Retrying in %d seconds\n",
2109
3103
                     (int)retry_interval);
2110
3104
      }
2111
 
      sleep((int)retry_interval);
 
3105
      sleep((unsigned int)retry_interval);
2112
3106
    }
2113
3107
    
2114
 
    if (not quit_now){
 
3108
    if(not quit_now){
2115
3109
      exitcode = EXIT_SUCCESS;
2116
3110
    }
2117
3111
    
2132
3126
    config.publish_domain = 0;
2133
3127
    
2134
3128
    /* Allocate a new server */
2135
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2136
 
                                 (mc.simple_poll), &config, NULL,
2137
 
                                 NULL, &error);
 
3129
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
3130
                                 &config, NULL, NULL, &ret);
2138
3131
    
2139
3132
    /* Free the Avahi configuration data */
2140
3133
    avahi_server_config_free(&config);
2143
3136
  /* Check if creating the Avahi server object succeeded */
2144
3137
  if(mc.server == NULL){
2145
3138
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2146
 
                 avahi_strerror(error));
 
3139
                 avahi_strerror(ret));
2147
3140
    exitcode = EX_UNAVAILABLE;
2148
3141
    goto end;
2149
3142
  }
2155
3148
  /* Create the Avahi service browser */
2156
3149
  sb = avahi_s_service_browser_new(mc.server, if_index,
2157
3150
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2158
 
                                   NULL, 0, browse_callback, NULL);
 
3151
                                   NULL, 0, browse_callback,
 
3152
                                   (void *)&mc);
2159
3153
  if(sb == NULL){
2160
3154
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
2161
3155
                 avahi_strerror(avahi_server_errno(mc.server)));
2172
3166
  if(debug){
2173
3167
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2174
3168
  }
2175
 
 
2176
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2177
 
                                (int)(retry_interval * 1000));
 
3169
  
 
3170
  ret = avahi_loop_with_timeout(simple_poll,
 
3171
                                (int)(retry_interval * 1000), &mc);
2178
3172
  if(debug){
2179
3173
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2180
3174
                 (ret == 0) ? "successfully" : "with error");
2183
3177
 end:
2184
3178
  
2185
3179
  if(debug){
2186
 
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3180
    if(signal_received){
 
3181
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
 
3182
                   argv[0], signal_received,
 
3183
                   strsignal(signal_received));
 
3184
    } else {
 
3185
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3186
    }
2187
3187
  }
2188
3188
  
2189
3189
  /* Cleanup things */
 
3190
  free(mc.interfaces);
 
3191
  
2190
3192
  if(sb != NULL)
2191
3193
    avahi_s_service_browser_free(sb);
2192
3194
  
2193
3195
  if(mc.server != NULL)
2194
3196
    avahi_server_free(mc.server);
2195
3197
  
2196
 
  if(mc.simple_poll != NULL)
2197
 
    avahi_simple_poll_free(mc.simple_poll);
 
3198
  if(simple_poll != NULL)
 
3199
    avahi_simple_poll_free(simple_poll);
2198
3200
  
2199
3201
  if(gnutls_initialized){
2200
3202
    gnutls_certificate_free_credentials(mc.cred);
2201
 
    gnutls_global_deinit();
2202
3203
    gnutls_dh_params_deinit(mc.dh_params);
2203
3204
  }
2204
3205
  
2212
3213
    mc.current_server->prev->next = NULL;
2213
3214
    while(mc.current_server != NULL){
2214
3215
      server *next = mc.current_server->next;
 
3216
#ifdef __GNUC__
 
3217
#pragma GCC diagnostic push
 
3218
#pragma GCC diagnostic ignored "-Wcast-qual"
 
3219
#endif
 
3220
      free((char *)(mc.current_server->ip));
 
3221
#ifdef __GNUC__
 
3222
#pragma GCC diagnostic pop
 
3223
#endif
2215
3224
      free(mc.current_server);
2216
3225
      mc.current_server = next;
2217
3226
    }
2218
3227
  }
2219
3228
  
2220
 
  /* Re-raise priviliges */
 
3229
  /* Re-raise privileges */
2221
3230
  {
2222
 
    if(getuid() == 0){
2223
 
      errno = 0;
2224
 
      ret = seteuid(0);
2225
 
      if(ret == -1){
2226
 
        perror_plus("seteuid");
 
3231
    ret = raise_privileges();
 
3232
    if(ret != 0){
 
3233
      errno = ret;
 
3234
      perror_plus("Failed to raise privileges");
 
3235
    } else {
 
3236
      
 
3237
      /* Run network hooks */
 
3238
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
3239
                        interfaces_hooks : "", delay);
 
3240
      
 
3241
      /* Take down the network interfaces which were brought up */
 
3242
      {
 
3243
        char *interface = NULL;
 
3244
        while((interface = argz_next(interfaces_to_take_down,
 
3245
                                     interfaces_to_take_down_size,
 
3246
                                     interface))){
 
3247
          ret = take_down_interface(interface);
 
3248
          if(ret != 0){
 
3249
            errno = ret;
 
3250
            perror_plus("Failed to take down interface");
 
3251
          }
 
3252
        }
 
3253
        if(debug and (interfaces_to_take_down == NULL)){
 
3254
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
3255
                       " down\n");
 
3256
        }
2227
3257
      }
2228
3258
    }
2229
3259
    
2230
 
    /* Run network hooks */
2231
 
    run_network_hooks("stop", interface, delay);
2232
 
    
2233
 
    /* Take down the network interface */
2234
 
    if(take_down_interface and geteuid() == 0){
2235
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2236
 
      if(ret == -1){
2237
 
        perror_plus("ioctl SIOCGIFFLAGS");
2238
 
      } else if(network.ifr_flags & IFF_UP){
2239
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2240
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2241
 
        if(ret == -1){
2242
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2243
 
        }
2244
 
      }
2245
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2246
 
      if(ret == -1){
2247
 
        perror_plus("close");
2248
 
      }
 
3260
    ret = lower_privileges_permanently();
 
3261
    if(ret != 0){
 
3262
      errno = ret;
 
3263
      perror_plus("Failed to lower privileges permanently");
2249
3264
    }
2250
3265
  }
2251
 
  if(getuid() == 0){
2252
 
    /* Lower privileges permanently */
2253
 
    errno = 0;
2254
 
    ret = setuid(uid);
2255
 
    if(ret == -1){
2256
 
      perror_plus("setuid");
2257
 
    }
 
3266
  
 
3267
  free(interfaces_to_take_down);
 
3268
  free(interfaces_hooks);
 
3269
  
 
3270
  void clean_dir_at(int base, const char * const dirname,
 
3271
                    uintmax_t level){
 
3272
    struct dirent **direntries = NULL;
 
3273
    int dret;
 
3274
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
 
3275
                                                O_RDONLY
 
3276
                                                | O_NOFOLLOW
 
3277
                                                | O_DIRECTORY
 
3278
                                                | O_PATH));
 
3279
    if(dir_fd == -1){
 
3280
      perror_plus("open");
 
3281
      return;
 
3282
    }
 
3283
    int numentries = scandirat(dir_fd, ".", &direntries,
 
3284
                               notdotentries, alphasort);
 
3285
    if(numentries >= 0){
 
3286
      for(int i = 0; i < numentries; i++){
 
3287
        if(debug){
 
3288
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
 
3289
                       dirname, direntries[i]->d_name);
 
3290
        }
 
3291
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
 
3292
        if(dret == -1){
 
3293
          if(errno == EISDIR){
 
3294
              dret = unlinkat(dir_fd, direntries[i]->d_name,
 
3295
                              AT_REMOVEDIR);
 
3296
          }         
 
3297
          if((dret == -1) and (errno == ENOTEMPTY)
 
3298
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
 
3299
                  == 0) and (level == 0)){
 
3300
            /* Recurse only in this special case */
 
3301
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
 
3302
            dret = 0;
 
3303
          }
 
3304
          if((dret == -1) and (errno != ENOENT)){
 
3305
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
 
3306
                         direntries[i]->d_name, strerror(errno));
 
3307
          }
 
3308
        }
 
3309
        free(direntries[i]);
 
3310
      }
 
3311
      
 
3312
      /* need to clean even if 0 because man page doesn't specify */
 
3313
      free(direntries);
 
3314
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
 
3315
      if(dret == -1 and errno != ENOENT){
 
3316
        perror_plus("rmdir");
 
3317
      }
 
3318
    } else {
 
3319
      perror_plus("scandirat");
 
3320
    }
 
3321
    close(dir_fd);
2258
3322
  }
2259
3323
  
2260
3324
  /* Removes the GPGME temp directory and all files inside */
2261
 
  if(tempdir_created){
2262
 
    struct dirent **direntries = NULL;
2263
 
    struct dirent *direntry = NULL;
2264
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2265
 
                             alphasort);
2266
 
    if (numentries > 0){
2267
 
      for(int i = 0; i < numentries; i++){
2268
 
        direntry = direntries[i];
2269
 
        char *fullname = NULL;
2270
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2271
 
                       direntry->d_name);
2272
 
        if(ret < 0){
2273
 
          perror_plus("asprintf");
2274
 
          continue;
2275
 
        }
2276
 
        ret = remove(fullname);
2277
 
        if(ret == -1){
2278
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2279
 
                       strerror(errno));
2280
 
        }
2281
 
        free(fullname);
2282
 
      }
2283
 
    }
2284
 
 
2285
 
    /* need to clean even if 0 because man page doesn't specify */
2286
 
    free(direntries);
2287
 
    if (numentries == -1){
2288
 
      perror_plus("scandir");
2289
 
    }
2290
 
    ret = rmdir(tempdir);
2291
 
    if(ret == -1 and errno != ENOENT){
2292
 
      perror_plus("rmdir");
2293
 
    }
 
3325
  if(tempdir != NULL){
 
3326
    clean_dir_at(-1, tempdir, 0);
2294
3327
  }
2295
3328
  
2296
3329
  if(quit_now){