/mandos/release

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

« back to all changes in this revision

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

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

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

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

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

Show diffs side-by-side

added added

removed removed

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