/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2016-03-17 20:40:55 UTC
  • Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.

Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2.  This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.

* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
  allocating new_argv.  Also tolerate a zero-length argv.

Show diffs side-by-side

added added

removed removed

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