/mandos/release

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2012-06-16 19:30:08 UTC
  • mto: (301.1.1 release) (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 302.
  • Revision ID: teddy@recompile.se-20120616193008-2erbfaw5a5y3yay1
* debian/mandos-client.README.Debian: Update documentation for using
                                      multiple interfaces.

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-2012 Teddy Hogeborn
 
13
 * Copyright © 2008-2012 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
 
36
#ifndef _FILE_OFFSET_BITS
33
37
#define _FILE_OFFSET_BITS 64
34
 
 
35
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
36
 
 
37
 
#include <stdio.h>
38
 
#include <assert.h>
39
 
#include <stdlib.h>
40
 
#include <time.h>
41
 
#include <net/if.h>             /* if_nametoindex */
42
 
#include <sys/ioctl.h>          // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
43
 
#include <net/if.h>             // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
44
 
 
 
38
#endif
 
39
 
 
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
 
41
 
 
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
 
43
                                   stdout, ferror(), remove() */
 
44
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
 
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
 
47
                                   strtof(), abort() */
 
48
#include <stdbool.h>            /* bool, false, true */
 
49
#include <string.h>             /* memset(), strcmp(), strlen(),
 
50
                                   strerror(), asprintf(), strcpy() */
 
51
#include <sys/ioctl.h>          /* ioctl */
 
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
 
53
                                   sockaddr_in6, PF_INET6,
 
54
                                   SOCK_STREAM, uid_t, gid_t, open(),
 
55
                                   opendir(), DIR */
 
56
#include <sys/stat.h>           /* open(), S_ISREG */
 
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
58
                                   inet_pton(), connect() */
 
59
#include <fcntl.h>              /* open() */
 
60
#include <dirent.h>             /* opendir(), struct dirent, readdir()
 
61
                                 */
 
62
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
 
63
                                   strtoimax() */
 
64
#include <errno.h>              /* perror(), errno,
 
65
                                   program_invocation_short_name */
 
66
#include <time.h>               /* nanosleep(), time(), sleep() */
 
67
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
 
68
                                   SIOCSIFFLAGS, if_indextoname(),
 
69
                                   if_nametoindex(), IF_NAMESIZE */
 
70
#include <netinet/in.h>         /* IN6_IS_ADDR_LINKLOCAL,
 
71
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
 
72
                                */
 
73
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
 
74
                                   getuid(), getgid(), seteuid(),
 
75
                                   setgid(), pause(), _exit() */
 
76
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
77
#include <iso646.h>             /* not, or, and */
 
78
#include <argp.h>               /* struct argp_option, error_t, struct
 
79
                                   argp_state, struct argp,
 
80
                                   argp_parse(), ARGP_KEY_ARG,
 
81
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
 
82
#include <signal.h>             /* sigemptyset(), sigaddset(),
 
83
                                   sigaction(), SIGTERM, sig_atomic_t,
 
84
                                   raise() */
 
85
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
86
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
 
87
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
 
88
                                   WEXITSTATUS(), WTERMSIG() */
 
89
#include <grp.h>                /* setgroups() */
 
90
#include <argz.h>               /* argz_add_sep(), argz_next(),
 
91
                                   argz_delete(), argz_append(),
 
92
                                   argz_stringify(), argz_add(),
 
93
                                   argz_count() */
 
94
 
 
95
#ifdef __linux__
 
96
#include <sys/klog.h>           /* klogctl() */
 
97
#endif  /* __linux__ */
 
98
 
 
99
/* Avahi */
 
100
/* All Avahi types, constants and functions
 
101
 Avahi*, avahi_*,
 
102
 AVAHI_* */
45
103
#include <avahi-core/core.h>
46
104
#include <avahi-core/lookup.h>
47
105
#include <avahi-core/log.h>
49
107
#include <avahi-common/malloc.h>
50
108
#include <avahi-common/error.h>
51
109
 
52
 
//mandos client part
53
 
#include <sys/types.h>          /* socket(), inet_pton() */
54
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
55
 
                                   struct in6_addr, inet_pton() */
56
 
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
57
 
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
58
 
 
59
 
#include <unistd.h>             /* close() */
60
 
#include <netinet/in.h>
61
 
#include <stdbool.h>            /* true */
62
 
#include <string.h>             /* memset */
63
 
#include <arpa/inet.h>          /* inet_pton() */
64
 
#include <iso646.h>             /* not */
65
 
 
66
 
// gpgme
67
 
#include <errno.h>              /* perror() */
68
 
#include <gpgme.h>
69
 
 
70
 
// getopt long
71
 
#include <getopt.h>
 
110
/* GnuTLS */
 
111
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
 
112
                                   functions:
 
113
                                   gnutls_*
 
114
                                   init_gnutls_session(),
 
115
                                   GNUTLS_* */
 
116
#include <gnutls/openpgp.h>
 
117
                         /* gnutls_certificate_set_openpgp_key_file(),
 
118
                            GNUTLS_OPENPGP_FMT_BASE64 */
 
119
 
 
120
/* GPGME */
 
121
#include <gpgme.h>              /* All GPGME types, constants and
 
122
                                   functions:
 
123
                                   gpgme_*
 
124
                                   GPGME_PROTOCOL_OpenPGP,
 
125
                                   GPG_ERR_NO_* */
72
126
 
73
127
#define BUFFER_SIZE 256
74
 
#define DH_BITS 1024
75
128
 
76
 
static const char *certdir = "/conf/conf.d/mandos";
77
 
static const char *certfile = "openpgp-client.txt";
78
 
static const char *certkey = "openpgp-client-key.txt";
 
129
#define PATHDIR "/conf/conf.d/mandos"
 
130
#define SECKEY "seckey.txt"
 
131
#define PUBKEY "pubkey.txt"
 
132
#define HOOKDIR "/lib/mandos/network-hooks.d"
79
133
 
80
134
bool debug = false;
81
 
 
82
 
const char mandos_protocol_version[] = "1";
83
 
 
 
135
static const char mandos_protocol_version[] = "1";
 
136
const char *argp_program_version = "mandos-client " VERSION;
 
137
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
138
static const char sys_class_net[] = "/sys/class/net";
 
139
char *connect_to = NULL;
 
140
const char *hookdir = HOOKDIR;
 
141
uid_t uid = 65534;
 
142
gid_t gid = 65534;
 
143
 
 
144
/* Doubly linked list that need to be circularly linked when used */
 
145
typedef struct server{
 
146
  const char *ip;
 
147
  in_port_t port;
 
148
  AvahiIfIndex if_index;
 
149
  int af;
 
150
  struct timespec last_seen;
 
151
  struct server *next;
 
152
  struct server *prev;
 
153
} server;
 
154
 
 
155
/* Used for passing in values through the Avahi callback functions */
84
156
typedef struct {
85
157
  AvahiSimplePoll *simple_poll;
86
158
  AvahiServer *server;
87
159
  gnutls_certificate_credentials_t cred;
88
160
  unsigned int dh_bits;
 
161
  gnutls_dh_params_t dh_params;
89
162
  const char *priority;
 
163
  gpgme_ctx_t ctx;
 
164
  server *current_server;
90
165
} mandos_context;
91
166
 
92
 
size_t adjustbuffer(char *buffer, size_t buffer_length,
93
 
                  size_t buffer_capacity){
94
 
  if (buffer_length + BUFFER_SIZE > buffer_capacity){
95
 
    buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
96
 
    if (buffer == NULL){
 
167
/* global context so signal handler can reach it*/
 
168
mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
169
                      .dh_bits = 1024, .priority = "SECURE256"
 
170
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
 
171
                      .current_server = NULL };
 
172
 
 
173
sig_atomic_t quit_now = 0;
 
174
int signal_received = 0;
 
175
 
 
176
/* Function to use when printing errors */
 
177
void perror_plus(const char *print_text){
 
178
  int e = errno;
 
179
  fprintf(stderr, "Mandos plugin %s: ",
 
180
          program_invocation_short_name);
 
181
  errno = e;
 
182
  perror(print_text);
 
183
}
 
184
 
 
185
__attribute__((format (gnu_printf, 2, 3)))
 
186
int fprintf_plus(FILE *stream, const char *format, ...){
 
187
  va_list ap;
 
188
  va_start (ap, format);
 
189
  
 
190
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
 
191
                             program_invocation_short_name));
 
192
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
193
}
 
194
 
 
195
/*
 
196
 * Make additional room in "buffer" for at least BUFFER_SIZE more
 
197
 * bytes. "buffer_capacity" is how much is currently allocated,
 
198
 * "buffer_length" is how much is already used.
 
199
 */
 
200
size_t incbuffer(char **buffer, size_t buffer_length,
 
201
                 size_t buffer_capacity){
 
202
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
 
203
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
204
    if(buffer == NULL){
97
205
      return 0;
98
206
    }
99
207
    buffer_capacity += BUFFER_SIZE;
101
209
  return buffer_capacity;
102
210
}
103
211
 
104
 
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
105
 
                                   char **new_packet,
106
 
                                   const char *homedir){
107
 
  gpgme_data_t dh_crypto, dh_plain;
108
 
  gpgme_ctx_t ctx;
 
212
/* Add server to set of servers to retry periodically */
 
213
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
214
                int af){
 
215
  int ret;
 
216
  server *new_server = malloc(sizeof(server));
 
217
  if(new_server == NULL){
 
218
    perror_plus("malloc");
 
219
    return false;
 
220
  }
 
221
  *new_server = (server){ .ip = strdup(ip),
 
222
                          .port = port,
 
223
                          .if_index = if_index,
 
224
                          .af = af };
 
225
  if(new_server->ip == NULL){
 
226
    perror_plus("strdup");
 
227
    return false;
 
228
  }
 
229
  /* Special case of first server */
 
230
  if (mc.current_server == NULL){
 
231
    new_server->next = new_server;
 
232
    new_server->prev = new_server;
 
233
    mc.current_server = new_server;
 
234
  /* Place the new server last in the list */
 
235
  } else {
 
236
    new_server->next = mc.current_server;
 
237
    new_server->prev = mc.current_server->prev;
 
238
    new_server->prev->next = new_server;
 
239
    mc.current_server->prev = new_server;
 
240
  }
 
241
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
 
242
  if(ret == -1){
 
243
    perror_plus("clock_gettime");
 
244
    return false;
 
245
  }
 
246
  return true;
 
247
}
 
248
 
 
249
/* 
 
250
 * Initialize GPGME.
 
251
 */
 
252
static bool init_gpgme(const char *seckey, const char *pubkey,
 
253
                       const char *tempdir){
109
254
  gpgme_error_t rc;
110
 
  ssize_t ret;
111
 
  size_t new_packet_capacity = 0;
112
 
  ssize_t new_packet_length = 0;
113
255
  gpgme_engine_info_t engine_info;
114
 
 
115
 
  if (debug){
116
 
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
 
256
  
 
257
  
 
258
  /*
 
259
   * Helper function to insert pub and seckey to the engine keyring.
 
260
   */
 
261
  bool import_key(const char *filename){
 
262
    int ret;
 
263
    int fd;
 
264
    gpgme_data_t pgp_data;
 
265
    
 
266
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
267
    if(fd == -1){
 
268
      perror_plus("open");
 
269
      return false;
 
270
    }
 
271
    
 
272
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
273
    if(rc != GPG_ERR_NO_ERROR){
 
274
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
275
                   gpgme_strsource(rc), gpgme_strerror(rc));
 
276
      return false;
 
277
    }
 
278
    
 
279
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
280
    if(rc != GPG_ERR_NO_ERROR){
 
281
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
 
282
                   gpgme_strsource(rc), gpgme_strerror(rc));
 
283
      return false;
 
284
    }
 
285
    
 
286
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
287
    if(ret == -1){
 
288
      perror_plus("close");
 
289
    }
 
290
    gpgme_data_release(pgp_data);
 
291
    return true;
 
292
  }
 
293
  
 
294
  if(debug){
 
295
    fprintf_plus(stderr, "Initializing GPGME\n");
117
296
  }
118
297
  
119
298
  /* Init GPGME */
120
299
  gpgme_check_version(NULL);
121
300
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
122
 
  if (rc != GPG_ERR_NO_ERROR){
123
 
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
124
 
            gpgme_strsource(rc), gpgme_strerror(rc));
125
 
    return -1;
 
301
  if(rc != GPG_ERR_NO_ERROR){
 
302
    fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
303
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
304
    return false;
126
305
  }
127
306
  
128
 
  /* Set GPGME home directory */
129
 
  rc = gpgme_get_engine_info (&engine_info);
130
 
  if (rc != GPG_ERR_NO_ERROR){
131
 
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
132
 
            gpgme_strsource(rc), gpgme_strerror(rc));
133
 
    return -1;
 
307
  /* Set GPGME home directory for the OpenPGP engine only */
 
308
  rc = gpgme_get_engine_info(&engine_info);
 
309
  if(rc != GPG_ERR_NO_ERROR){
 
310
    fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
311
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
312
    return false;
134
313
  }
135
314
  while(engine_info != NULL){
136
315
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
137
316
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
138
 
                            engine_info->file_name, homedir);
 
317
                            engine_info->file_name, tempdir);
139
318
      break;
140
319
    }
141
320
    engine_info = engine_info->next;
142
321
  }
143
322
  if(engine_info == NULL){
144
 
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
145
 
    return -1;
146
 
  }
147
 
  
148
 
  /* Create new GPGME data buffer from packet buffer */
149
 
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
150
 
  if (rc != GPG_ERR_NO_ERROR){
151
 
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
152
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
323
    fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
 
324
                 tempdir);
 
325
    return false;
 
326
  }
 
327
  
 
328
  /* Create new GPGME "context" */
 
329
  rc = gpgme_new(&(mc.ctx));
 
330
  if(rc != GPG_ERR_NO_ERROR){
 
331
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
332
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
 
333
                 gpgme_strerror(rc));
 
334
    return false;
 
335
  }
 
336
  
 
337
  if(not import_key(pubkey) or not import_key(seckey)){
 
338
    return false;
 
339
  }
 
340
  
 
341
  return true;
 
342
}
 
343
 
 
344
/* 
 
345
 * Decrypt OpenPGP data.
 
346
 * Returns -1 on error
 
347
 */
 
348
static ssize_t pgp_packet_decrypt(const char *cryptotext,
 
349
                                  size_t crypto_size,
 
350
                                  char **plaintext){
 
351
  gpgme_data_t dh_crypto, dh_plain;
 
352
  gpgme_error_t rc;
 
353
  ssize_t ret;
 
354
  size_t plaintext_capacity = 0;
 
355
  ssize_t plaintext_length = 0;
 
356
  
 
357
  if(debug){
 
358
    fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
 
359
  }
 
360
  
 
361
  /* Create new GPGME data buffer from memory cryptotext */
 
362
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
363
                               0);
 
364
  if(rc != GPG_ERR_NO_ERROR){
 
365
    fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
366
                 gpgme_strsource(rc), gpgme_strerror(rc));
153
367
    return -1;
154
368
  }
155
369
  
156
370
  /* Create new empty GPGME data buffer for the plaintext */
157
371
  rc = gpgme_data_new(&dh_plain);
158
 
  if (rc != GPG_ERR_NO_ERROR){
159
 
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
160
 
            gpgme_strsource(rc), gpgme_strerror(rc));
161
 
    return -1;
162
 
  }
163
 
  
164
 
  /* Create new GPGME "context" */
165
 
  rc = gpgme_new(&ctx);
166
 
  if (rc != GPG_ERR_NO_ERROR){
167
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
168
 
            gpgme_strsource(rc), gpgme_strerror(rc));
169
 
    return -1;
170
 
  }
171
 
  
172
 
  /* Decrypt data from the FILE pointer to the plaintext data
173
 
     buffer */
174
 
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
175
 
  if (rc != GPG_ERR_NO_ERROR){
176
 
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
177
 
            gpgme_strsource(rc), gpgme_strerror(rc));
178
 
    return -1;
179
 
  }
180
 
 
181
 
  if(debug){
182
 
    fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
183
 
  }
184
 
 
185
 
  if (debug){
186
 
    gpgme_decrypt_result_t result;
187
 
    result = gpgme_op_decrypt_result(ctx);
188
 
    if (result == NULL){
189
 
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
190
 
    } else {
191
 
      fprintf(stderr, "Unsupported algorithm: %s\n",
192
 
              result->unsupported_algorithm);
193
 
      fprintf(stderr, "Wrong key usage: %d\n",
194
 
              result->wrong_key_usage);
195
 
      if(result->file_name != NULL){
196
 
        fprintf(stderr, "File name: %s\n", result->file_name);
197
 
      }
198
 
      gpgme_recipient_t recipient;
199
 
      recipient = result->recipients;
200
 
      if(recipient){
 
372
  if(rc != GPG_ERR_NO_ERROR){
 
373
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
374
                 "bad gpgme_data_new: %s: %s\n",
 
375
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
376
    gpgme_data_release(dh_crypto);
 
377
    return -1;
 
378
  }
 
379
  
 
380
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
381
     data buffer */
 
382
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
383
  if(rc != GPG_ERR_NO_ERROR){
 
384
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
385
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
386
    plaintext_length = -1;
 
387
    if(debug){
 
388
      gpgme_decrypt_result_t result;
 
389
      result = gpgme_op_decrypt_result(mc.ctx);
 
390
      if(result == NULL){
 
391
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
 
392
      } else {
 
393
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
394
                     result->unsupported_algorithm);
 
395
        fprintf_plus(stderr, "Wrong key usage: %u\n",
 
396
                     result->wrong_key_usage);
 
397
        if(result->file_name != NULL){
 
398
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
 
399
        }
 
400
        gpgme_recipient_t recipient;
 
401
        recipient = result->recipients;
201
402
        while(recipient != NULL){
202
 
          fprintf(stderr, "Public key algorithm: %s\n",
203
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
204
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
205
 
          fprintf(stderr, "Secret key available: %s\n",
206
 
                  recipient->status == GPG_ERR_NO_SECKEY
207
 
                  ? "No" : "Yes");
 
403
          fprintf_plus(stderr, "Public key algorithm: %s\n",
 
404
                       gpgme_pubkey_algo_name
 
405
                       (recipient->pubkey_algo));
 
406
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
407
          fprintf_plus(stderr, "Secret key available: %s\n",
 
408
                       recipient->status == GPG_ERR_NO_SECKEY
 
409
                       ? "No" : "Yes");
208
410
          recipient = recipient->next;
209
411
        }
210
412
      }
211
413
    }
 
414
    goto decrypt_end;
212
415
  }
213
416
  
214
 
  /* Delete the GPGME FILE pointer cryptotext data buffer */
215
 
  gpgme_data_release(dh_crypto);
 
417
  if(debug){
 
418
    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
 
419
  }
216
420
  
217
421
  /* Seek back to the beginning of the GPGME plaintext data buffer */
218
 
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
219
 
    perror("pgpme_data_seek");
 
422
  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
 
423
    perror_plus("gpgme_data_seek");
 
424
    plaintext_length = -1;
 
425
    goto decrypt_end;
220
426
  }
221
427
  
222
 
  *new_packet = 0;
 
428
  *plaintext = NULL;
223
429
  while(true){
224
 
    new_packet_capacity = adjustbuffer(*new_packet, new_packet_length,
225
 
                                       new_packet_capacity);
226
 
    if (new_packet_capacity == 0){
227
 
        perror("adjustbuffer");
228
 
        return -1;
229
 
      }
230
 
      new_packet_capacity += BUFFER_SIZE;
 
430
    plaintext_capacity = incbuffer(plaintext,
 
431
                                   (size_t)plaintext_length,
 
432
                                   plaintext_capacity);
 
433
    if(plaintext_capacity == 0){
 
434
      perror_plus("incbuffer");
 
435
      plaintext_length = -1;
 
436
      goto decrypt_end;
231
437
    }
232
438
    
233
 
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
 
439
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
234
440
                          BUFFER_SIZE);
235
441
    /* Print the data, if any */
236
 
    if (ret == 0){
 
442
    if(ret == 0){
 
443
      /* EOF */
237
444
      break;
238
445
    }
239
446
    if(ret < 0){
240
 
      perror("gpgme_data_read");
241
 
      return -1;
242
 
    }
243
 
    new_packet_length += ret;
244
 
  }
245
 
 
246
 
  /* FIXME: check characters before printing to screen so to not print
247
 
     terminal control characters */
248
 
  /*   if(debug){ */
249
 
  /*     fprintf(stderr, "decrypted password is: "); */
250
 
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
251
 
  /*     fprintf(stderr, "\n"); */
252
 
  /*   } */
 
447
      perror_plus("gpgme_data_read");
 
448
      plaintext_length = -1;
 
449
      goto decrypt_end;
 
450
    }
 
451
    plaintext_length += ret;
 
452
  }
 
453
  
 
454
  if(debug){
 
455
    fprintf_plus(stderr, "Decrypted password is: ");
 
456
    for(ssize_t i = 0; i < plaintext_length; i++){
 
457
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
 
458
    }
 
459
    fprintf(stderr, "\n");
 
460
  }
 
461
  
 
462
 decrypt_end:
 
463
  
 
464
  /* Delete the GPGME cryptotext data buffer */
 
465
  gpgme_data_release(dh_crypto);
253
466
  
254
467
  /* Delete the GPGME plaintext data buffer */
255
468
  gpgme_data_release(dh_plain);
256
 
  return new_packet_length;
 
469
  return plaintext_length;
257
470
}
258
471
 
259
 
static const char * safer_gnutls_strerror (int value) {
260
 
  const char *ret = gnutls_strerror (value);
261
 
  if (ret == NULL)
 
472
static const char * safer_gnutls_strerror(int value){
 
473
  const char *ret = gnutls_strerror(value);
 
474
  if(ret == NULL)
262
475
    ret = "(unknown)";
263
476
  return ret;
264
477
}
265
478
 
 
479
/* GnuTLS log function callback */
266
480
static void debuggnutls(__attribute__((unused)) int level,
267
481
                        const char* string){
268
 
  fprintf(stderr, "%s", string);
 
482
  fprintf_plus(stderr, "GnuTLS: %s", string);
269
483
}
270
484
 
271
 
static int initgnutls(mandos_context *mc){
272
 
  const char *err;
 
485
static int init_gnutls_global(const char *pubkeyfilename,
 
486
                              const char *seckeyfilename){
273
487
  int ret;
274
488
  
275
489
  if(debug){
276
 
    fprintf(stderr, "Initializing GnuTLS\n");
 
490
    fprintf_plus(stderr, "Initializing GnuTLS\n");
277
491
  }
278
 
 
279
 
  if ((ret = gnutls_global_init ())
280
 
      != GNUTLS_E_SUCCESS) {
281
 
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
492
  
 
493
  ret = gnutls_global_init();
 
494
  if(ret != GNUTLS_E_SUCCESS){
 
495
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
496
                 safer_gnutls_strerror(ret));
282
497
    return -1;
283
498
  }
284
 
 
285
 
  if (debug){
 
499
  
 
500
  if(debug){
 
501
    /* "Use a log level over 10 to enable all debugging options."
 
502
     * - GnuTLS manual
 
503
     */
286
504
    gnutls_global_set_log_level(11);
287
505
    gnutls_global_set_log_function(debuggnutls);
288
506
  }
289
507
  
290
 
  /* openpgp credentials */
291
 
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
292
 
      != GNUTLS_E_SUCCESS) {
293
 
    fprintf (stderr, "memory error: %s\n",
294
 
             safer_gnutls_strerror(ret));
 
508
  /* OpenPGP credentials */
 
509
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
510
  if(ret != GNUTLS_E_SUCCESS){
 
511
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
 
512
                 safer_gnutls_strerror(ret));
 
513
    gnutls_global_deinit();
295
514
    return -1;
296
515
  }
297
516
  
298
517
  if(debug){
299
 
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
300
 
            " and keyfile %s as GnuTLS credentials\n", certfile,
301
 
            certkey);
 
518
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
519
                 " secret key %s as GnuTLS credentials\n",
 
520
                 pubkeyfilename,
 
521
                 seckeyfilename);
302
522
  }
303
523
  
304
524
  ret = gnutls_certificate_set_openpgp_key_file
305
 
    (es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
306
 
  if (ret != GNUTLS_E_SUCCESS) {
307
 
    fprintf
308
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
309
 
       " '%s')\n",
310
 
       ret, certfile, certkey);
311
 
    fprintf(stdout, "The Error is: %s\n",
312
 
            safer_gnutls_strerror(ret));
313
 
    return -1;
314
 
  }
315
 
  
316
 
  //GnuTLS server initialization
317
 
  if ((ret = gnutls_dh_params_init (&es->dh_params))
318
 
      != GNUTLS_E_SUCCESS) {
319
 
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
320
 
             safer_gnutls_strerror(ret));
321
 
    return -1;
322
 
  }
323
 
  
324
 
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
325
 
      != GNUTLS_E_SUCCESS) {
326
 
    fprintf (stderr, "Error in prime generation: %s\n",
327
 
             safer_gnutls_strerror(ret));
328
 
    return -1;
329
 
  }
330
 
  
331
 
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
332
 
  
333
 
  // GnuTLS session creation
334
 
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
335
 
      != GNUTLS_E_SUCCESS){
336
 
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
337
 
            safer_gnutls_strerror(ret));
338
 
  }
339
 
  
340
 
  if ((ret = gnutls_priority_set_direct (es->session, mc->priority, &err))
341
 
      != GNUTLS_E_SUCCESS) {
342
 
    fprintf(stderr, "Syntax error at: %s\n", err);
343
 
    fprintf(stderr, "GnuTLS error: %s\n",
344
 
            safer_gnutls_strerror(ret));
345
 
    return -1;
346
 
  }
347
 
  
348
 
  if ((ret = gnutls_credentials_set
349
 
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
350
 
      != GNUTLS_E_SUCCESS) {
351
 
    fprintf(stderr, "Error setting a credentials set: %s\n",
352
 
            safer_gnutls_strerror(ret));
 
525
    (mc.cred, pubkeyfilename, seckeyfilename,
 
526
     GNUTLS_OPENPGP_FMT_BASE64);
 
527
  if(ret != GNUTLS_E_SUCCESS){
 
528
    fprintf_plus(stderr,
 
529
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
530
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
531
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
 
532
                 safer_gnutls_strerror(ret));
 
533
    goto globalfail;
 
534
  }
 
535
  
 
536
  /* GnuTLS server initialization */
 
537
  ret = gnutls_dh_params_init(&mc.dh_params);
 
538
  if(ret != GNUTLS_E_SUCCESS){
 
539
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
 
540
                 " initialization: %s\n",
 
541
                 safer_gnutls_strerror(ret));
 
542
    goto globalfail;
 
543
  }
 
544
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
545
  if(ret != GNUTLS_E_SUCCESS){
 
546
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
 
547
                 safer_gnutls_strerror(ret));
 
548
    goto globalfail;
 
549
  }
 
550
  
 
551
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
552
  
 
553
  return 0;
 
554
  
 
555
 globalfail:
 
556
  
 
557
  gnutls_certificate_free_credentials(mc.cred);
 
558
  gnutls_global_deinit();
 
559
  gnutls_dh_params_deinit(mc.dh_params);
 
560
  return -1;
 
561
}
 
562
 
 
563
static int init_gnutls_session(gnutls_session_t *session){
 
564
  int ret;
 
565
  /* GnuTLS session creation */
 
566
  do {
 
567
    ret = gnutls_init(session, GNUTLS_SERVER);
 
568
    if(quit_now){
 
569
      return -1;
 
570
    }
 
571
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
572
  if(ret != GNUTLS_E_SUCCESS){
 
573
    fprintf_plus(stderr,
 
574
                 "Error in GnuTLS session initialization: %s\n",
 
575
                 safer_gnutls_strerror(ret));
 
576
  }
 
577
  
 
578
  {
 
579
    const char *err;
 
580
    do {
 
581
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
582
      if(quit_now){
 
583
        gnutls_deinit(*session);
 
584
        return -1;
 
585
      }
 
586
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
587
    if(ret != GNUTLS_E_SUCCESS){
 
588
      fprintf_plus(stderr, "Syntax error at: %s\n", err);
 
589
      fprintf_plus(stderr, "GnuTLS error: %s\n",
 
590
                   safer_gnutls_strerror(ret));
 
591
      gnutls_deinit(*session);
 
592
      return -1;
 
593
    }
 
594
  }
 
595
  
 
596
  do {
 
597
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
598
                                 mc.cred);
 
599
    if(quit_now){
 
600
      gnutls_deinit(*session);
 
601
      return -1;
 
602
    }
 
603
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
604
  if(ret != GNUTLS_E_SUCCESS){
 
605
    fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
 
606
                 safer_gnutls_strerror(ret));
 
607
    gnutls_deinit(*session);
353
608
    return -1;
354
609
  }
355
610
  
356
611
  /* ignore client certificate if any. */
357
 
  gnutls_certificate_server_set_request (es->session,
358
 
                                         GNUTLS_CERT_IGNORE);
 
612
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
359
613
  
360
 
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
 
614
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
361
615
  
362
616
  return 0;
363
617
}
364
618
 
 
619
/* Avahi log function callback */
365
620
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
366
621
                      __attribute__((unused)) const char *txt){}
367
622
 
368
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
623
/* Called when a Mandos server is found */
 
624
static int start_mandos_communication(const char *ip, in_port_t port,
369
625
                                      AvahiIfIndex if_index,
370
 
                                      mandos_context *mc){
371
 
  int ret, tcp_sd;
372
 
  struct sockaddr_in6 to;
373
 
  encrypted_session es;
 
626
                                      int af){
 
627
  int ret, tcp_sd = -1;
 
628
  ssize_t sret;
 
629
  union {
 
630
    struct sockaddr_in in;
 
631
    struct sockaddr_in6 in6;
 
632
  } to;
374
633
  char *buffer = NULL;
375
 
  char *decrypted_buffer;
 
634
  char *decrypted_buffer = NULL;
376
635
  size_t buffer_length = 0;
377
636
  size_t buffer_capacity = 0;
378
 
  ssize_t decrypted_buffer_size;
379
637
  size_t written;
380
 
  int retval = 0;
381
 
  char interface[IF_NAMESIZE];
382
 
  
383
 
  if(debug){
384
 
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
385
 
            ip, port);
386
 
  }
387
 
  
388
 
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
389
 
  if(tcp_sd < 0) {
390
 
    perror("socket");
391
 
    return -1;
392
 
  }
393
 
 
394
 
  if(debug){
395
 
    if(if_indextoname((unsigned int)if_index, interface) == NULL){
396
 
      if(debug){
397
 
        perror("if_indextoname");
398
 
      }
399
 
      return -1;
400
 
    }
401
 
    
402
 
    fprintf(stderr, "Binding to interface %s\n", interface);
403
 
  }
404
 
  
405
 
  memset(&to,0,sizeof(to));     /* Spurious warning */
406
 
  to.sin6_family = AF_INET6;
407
 
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
408
 
  if (ret < 0 ){
409
 
    perror("inet_pton");
410
 
    return -1;
411
 
  }  
 
638
  int retval = -1;
 
639
  gnutls_session_t session;
 
640
  int pf;                       /* Protocol family */
 
641
  
 
642
  errno = 0;
 
643
  
 
644
  if(quit_now){
 
645
    errno = EINTR;
 
646
    return -1;
 
647
  }
 
648
  
 
649
  switch(af){
 
650
  case AF_INET6:
 
651
    pf = PF_INET6;
 
652
    break;
 
653
  case AF_INET:
 
654
    pf = PF_INET;
 
655
    break;
 
656
  default:
 
657
    fprintf_plus(stderr, "Bad address family: %d\n", af);
 
658
    errno = EINVAL;
 
659
    return -1;
 
660
  }
 
661
  
 
662
  ret = init_gnutls_session(&session);
 
663
  if(ret != 0){
 
664
    return -1;
 
665
  }
 
666
  
 
667
  if(debug){
 
668
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
 
669
                 PRIuMAX "\n", ip, (uintmax_t)port);
 
670
  }
 
671
  
 
672
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
673
  if(tcp_sd < 0){
 
674
    int e = errno;
 
675
    perror_plus("socket");
 
676
    errno = e;
 
677
    goto mandos_end;
 
678
  }
 
679
  
 
680
  if(quit_now){
 
681
    errno = EINTR;
 
682
    goto mandos_end;
 
683
  }
 
684
  
 
685
  memset(&to, 0, sizeof(to));
 
686
  if(af == AF_INET6){
 
687
    to.in6.sin6_family = (sa_family_t)af;
 
688
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
689
  } else {                      /* IPv4 */
 
690
    to.in.sin_family = (sa_family_t)af;
 
691
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
692
  }
 
693
  if(ret < 0 ){
 
694
    int e = errno;
 
695
    perror_plus("inet_pton");
 
696
    errno = e;
 
697
    goto mandos_end;
 
698
  }
412
699
  if(ret == 0){
413
 
    fprintf(stderr, "Bad address: %s\n", ip);
414
 
    return -1;
415
 
  }
416
 
  to.sin6_port = htons(port);   /* Spurious warning */
 
700
    int e = errno;
 
701
    fprintf_plus(stderr, "Bad address: %s\n", ip);
 
702
    errno = e;
 
703
    goto mandos_end;
 
704
  }
 
705
  if(af == AF_INET6){
 
706
    to.in6.sin6_port = htons(port);    
 
707
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
 
708
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
 
709
                                -Wunreachable-code*/
 
710
      if(if_index == AVAHI_IF_UNSPEC){
 
711
        fprintf_plus(stderr, "An IPv6 link-local address is"
 
712
                     " incomplete without a network interface\n");
 
713
        errno = EINVAL;
 
714
        goto mandos_end;
 
715
      }
 
716
      /* Set the network interface number as scope */
 
717
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
718
    }
 
719
  } else {
 
720
    to.in.sin_port = htons(port); /* Spurious warnings from
 
721
                                     -Wconversion and
 
722
                                     -Wunreachable-code */
 
723
  }
417
724
  
418
 
  to.sin6_scope_id = (uint32_t)if_index;
 
725
  if(quit_now){
 
726
    errno = EINTR;
 
727
    goto mandos_end;
 
728
  }
419
729
  
420
730
  if(debug){
421
 
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
422
 
/*     char addrstr[INET6_ADDRSTRLEN]; */
423
 
/*     if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr, */
424
 
/*               sizeof(addrstr)) == NULL){ */
425
 
/*       perror("inet_ntop"); */
426
 
/*     } else { */
427
 
/*       fprintf(stderr, "Really connecting to: %s, port %d\n", */
428
 
/*            addrstr, ntohs(to.sin6_port)); */
429
 
/*     } */
430
 
  }
431
 
  
432
 
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
433
 
  if (ret < 0){
434
 
    perror("connect");
435
 
    return -1;
436
 
  }
437
 
 
438
 
  char *out = mandos_protocol_version;
 
731
    if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
 
732
      char interface[IF_NAMESIZE];
 
733
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
734
        perror_plus("if_indextoname");
 
735
      } else {
 
736
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
737
                     "\n", ip, interface, (uintmax_t)port);
 
738
      }
 
739
    } else {
 
740
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
741
                   ip, (uintmax_t)port);
 
742
    }
 
743
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
 
744
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
 
745
    const char *pcret;
 
746
    if(af == AF_INET6){
 
747
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
 
748
                        sizeof(addrstr));
 
749
    } else {
 
750
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
 
751
                        sizeof(addrstr));
 
752
    }
 
753
    if(pcret == NULL){
 
754
      perror_plus("inet_ntop");
 
755
    } else {
 
756
      if(strcmp(addrstr, ip) != 0){
 
757
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
 
758
      }
 
759
    }
 
760
  }
 
761
  
 
762
  if(quit_now){
 
763
    errno = EINTR;
 
764
    goto mandos_end;
 
765
  }
 
766
  
 
767
  if(af == AF_INET6){
 
768
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
769
  } else {
 
770
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
771
  }
 
772
  if(ret < 0){
 
773
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
774
      int e = errno;
 
775
      perror_plus("connect");
 
776
      errno = e;
 
777
    }
 
778
    goto mandos_end;
 
779
  }
 
780
  
 
781
  if(quit_now){
 
782
    errno = EINTR;
 
783
    goto mandos_end;
 
784
  }
 
785
  
 
786
  const char *out = mandos_protocol_version;
439
787
  written = 0;
440
 
  while (true){
 
788
  while(true){
441
789
    size_t out_size = strlen(out);
442
 
    ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
443
 
                                   out_size - written));
444
 
    if (ret == -1){
445
 
      perror("write");
446
 
      retval = -1;
447
 
      goto end;
 
790
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
 
791
                                        out_size - written));
 
792
    if(ret == -1){
 
793
      int e = errno;
 
794
      perror_plus("write");
 
795
      errno = e;
 
796
      goto mandos_end;
448
797
    }
449
 
    written += ret;
 
798
    written += (size_t)ret;
450
799
    if(written < out_size){
451
800
      continue;
452
801
    } else {
453
 
      if (out == mandos_protocol_version){
 
802
      if(out == mandos_protocol_version){
454
803
        written = 0;
455
804
        out = "\r\n";
456
805
      } else {
457
806
        break;
458
807
      }
459
808
    }
460
 
  }
461
 
 
462
 
  ret = initgnutls (&es);
463
 
  if (ret != 0){
464
 
    retval = -1;
465
 
    return -1;
466
 
  }
467
809
  
468
 
  gnutls_transport_set_ptr (es.session,
469
 
                            (gnutls_transport_ptr_t) tcp_sd);
 
810
    if(quit_now){
 
811
      errno = EINTR;
 
812
      goto mandos_end;
 
813
    }
 
814
  }
470
815
  
471
816
  if(debug){
472
 
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
473
 
  }
474
 
  
475
 
  ret = gnutls_handshake (es.session);
476
 
  
477
 
  if (ret != GNUTLS_E_SUCCESS){
 
817
    fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
 
818
  }
 
819
  
 
820
  if(quit_now){
 
821
    errno = EINTR;
 
822
    goto mandos_end;
 
823
  }
 
824
  
 
825
  /* This casting via intptr_t is to eliminate warning about casting
 
826
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
827
     function "set-session-transport-fd!" does it. */
 
828
  gnutls_transport_set_ptr(session,
 
829
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
 
830
  
 
831
  if(quit_now){
 
832
    errno = EINTR;
 
833
    goto mandos_end;
 
834
  }
 
835
  
 
836
  do {
 
837
    ret = gnutls_handshake(session);
 
838
    if(quit_now){
 
839
      errno = EINTR;
 
840
      goto mandos_end;
 
841
    }
 
842
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
843
  
 
844
  if(ret != GNUTLS_E_SUCCESS){
478
845
    if(debug){
479
 
      fprintf(stderr, "\n*** Handshake failed ***\n");
480
 
      gnutls_perror (ret);
 
846
      fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
 
847
      gnutls_perror(ret);
481
848
    }
482
 
    retval = -1;
483
 
    goto exit;
 
849
    errno = EPROTO;
 
850
    goto mandos_end;
484
851
  }
485
852
  
486
 
  //Retrieve OpenPGP packet that contains the wanted password
 
853
  /* Read OpenPGP packet that contains the wanted password */
487
854
  
488
855
  if(debug){
489
 
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
490
 
            ip);
 
856
    fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
 
857
                 " %s\n", ip);
491
858
  }
492
 
 
 
859
  
493
860
  while(true){
494
 
    buffer_capacity = adjustbuffer(buffer, buffer_length, buffer_capacity);
495
 
    if (buffer_capacity == 0){
496
 
      perror("adjustbuffer");
497
 
      retval = -1;
498
 
      goto exit;
499
 
    }
500
 
    
501
 
    ret = gnutls_record_recv
502
 
      (es.session, buffer+buffer_length, BUFFER_SIZE);
503
 
    if (ret == 0){
 
861
    
 
862
    if(quit_now){
 
863
      errno = EINTR;
 
864
      goto mandos_end;
 
865
    }
 
866
    
 
867
    buffer_capacity = incbuffer(&buffer, buffer_length,
 
868
                                buffer_capacity);
 
869
    if(buffer_capacity == 0){
 
870
      int e = errno;
 
871
      perror_plus("incbuffer");
 
872
      errno = e;
 
873
      goto mandos_end;
 
874
    }
 
875
    
 
876
    if(quit_now){
 
877
      errno = EINTR;
 
878
      goto mandos_end;
 
879
    }
 
880
    
 
881
    sret = gnutls_record_recv(session, buffer+buffer_length,
 
882
                              BUFFER_SIZE);
 
883
    if(sret == 0){
504
884
      break;
505
885
    }
506
 
    if (ret < 0){
507
 
      switch(ret){
 
886
    if(sret < 0){
 
887
      switch(sret){
508
888
      case GNUTLS_E_INTERRUPTED:
509
889
      case GNUTLS_E_AGAIN:
510
890
        break;
511
891
      case GNUTLS_E_REHANDSHAKE:
512
 
        ret = gnutls_handshake (es.session);
513
 
        if (ret < 0){
514
 
          fprintf(stderr, "\n*** Handshake failed ***\n");
515
 
          gnutls_perror (ret);
516
 
          retval = -1;
517
 
          goto exit;
 
892
        do {
 
893
          ret = gnutls_handshake(session);
 
894
          
 
895
          if(quit_now){
 
896
            errno = EINTR;
 
897
            goto mandos_end;
 
898
          }
 
899
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
900
        if(ret < 0){
 
901
          fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
 
902
                       "***\n");
 
903
          gnutls_perror(ret);
 
904
          errno = EPROTO;
 
905
          goto mandos_end;
518
906
        }
519
907
        break;
520
908
      default:
521
 
        fprintf(stderr, "Unknown error while reading data from"
522
 
                " encrypted session with mandos server\n");
523
 
        retval = -1;
524
 
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
525
 
        goto exit;
 
909
        fprintf_plus(stderr, "Unknown error while reading data from"
 
910
                     " encrypted session with Mandos server\n");
 
911
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
912
        errno = EIO;
 
913
        goto mandos_end;
526
914
      }
527
915
    } else {
528
 
      buffer_length += (size_t) ret;
529
 
    }
530
 
  }
531
 
  
532
 
  if (buffer_length > 0){
533
 
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
534
 
                                               buffer_length,
535
 
                                               &decrypted_buffer,
536
 
                                               certdir);
537
 
    if (decrypted_buffer_size >= 0){
 
916
      buffer_length += (size_t) sret;
 
917
    }
 
918
  }
 
919
  
 
920
  if(debug){
 
921
    fprintf_plus(stderr, "Closing TLS session\n");
 
922
  }
 
923
  
 
924
  if(quit_now){
 
925
    errno = EINTR;
 
926
    goto mandos_end;
 
927
  }
 
928
  
 
929
  do {
 
930
    ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
931
    if(quit_now){
 
932
      errno = EINTR;
 
933
      goto mandos_end;
 
934
    }
 
935
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
936
  
 
937
  if(buffer_length > 0){
 
938
    ssize_t decrypted_buffer_size;
 
939
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
 
940
                                               &decrypted_buffer);
 
941
    if(decrypted_buffer_size >= 0){
 
942
      
538
943
      written = 0;
539
944
      while(written < (size_t) decrypted_buffer_size){
540
 
        ret = (int)fwrite (decrypted_buffer + written, 1,
541
 
                           (size_t)decrypted_buffer_size - written,
542
 
                           stdout);
 
945
        if(quit_now){
 
946
          errno = EINTR;
 
947
          goto mandos_end;
 
948
        }
 
949
        
 
950
        ret = (int)fwrite(decrypted_buffer + written, 1,
 
951
                          (size_t)decrypted_buffer_size - written,
 
952
                          stdout);
543
953
        if(ret == 0 and ferror(stdout)){
 
954
          int e = errno;
544
955
          if(debug){
545
 
            fprintf(stderr, "Error writing encrypted data: %s\n",
546
 
                    strerror(errno));
 
956
            fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
957
                         strerror(errno));
547
958
          }
548
 
          retval = -1;
549
 
          break;
 
959
          errno = e;
 
960
          goto mandos_end;
550
961
        }
551
962
        written += (size_t)ret;
552
963
      }
553
 
      free(decrypted_buffer);
554
 
    } else {
 
964
      retval = 0;
 
965
    }
 
966
  }
 
967
  
 
968
  /* Shutdown procedure */
 
969
  
 
970
 mandos_end:
 
971
  {
 
972
    int e = errno;
 
973
    free(decrypted_buffer);
 
974
    free(buffer);
 
975
    if(tcp_sd >= 0){
 
976
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
977
    }
 
978
    if(ret == -1){
 
979
      if(e == 0){
 
980
        e = errno;
 
981
      }
 
982
      perror_plus("close");
 
983
    }
 
984
    gnutls_deinit(session);
 
985
    errno = e;
 
986
    if(quit_now){
 
987
      errno = EINTR;
555
988
      retval = -1;
556
989
    }
557
990
  }
558
 
 
559
 
  //shutdown procedure
560
 
 
561
 
  if(debug){
562
 
    fprintf(stderr, "Closing TLS session\n");
563
 
  }
564
 
 
565
 
  free(buffer);
566
 
  gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
567
 
 exit:
568
 
  close(tcp_sd);
569
 
  gnutls_deinit (es.session);
570
 
  gnutls_certificate_free_credentials (es.cred);
571
 
  gnutls_global_deinit ();
572
991
  return retval;
573
992
}
574
993
 
575
 
static void resolve_callback( AvahiSServiceResolver *r,
576
 
                              AvahiIfIndex interface,
577
 
                              AVAHI_GCC_UNUSED AvahiProtocol protocol,
578
 
                              AvahiResolverEvent event,
579
 
                              const char *name,
580
 
                              const char *type,
581
 
                              const char *domain,
582
 
                              const char *host_name,
583
 
                              const AvahiAddress *address,
584
 
                              uint16_t port,
585
 
                              AVAHI_GCC_UNUSED AvahiStringList *txt,
586
 
                              AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
587
 
                              AVAHI_GCC_UNUSED void* userdata) {
588
 
  mandos_context *mc = userdata;
589
 
  assert(r);                    /* Spurious warning */
 
994
static void resolve_callback(AvahiSServiceResolver *r,
 
995
                             AvahiIfIndex interface,
 
996
                             AvahiProtocol proto,
 
997
                             AvahiResolverEvent event,
 
998
                             const char *name,
 
999
                             const char *type,
 
1000
                             const char *domain,
 
1001
                             const char *host_name,
 
1002
                             const AvahiAddress *address,
 
1003
                             uint16_t port,
 
1004
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
 
1005
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
1006
                             flags,
 
1007
                             AVAHI_GCC_UNUSED void* userdata){
 
1008
  if(r == NULL){
 
1009
    return;
 
1010
  }
590
1011
  
591
1012
  /* Called whenever a service has been resolved successfully or
592
1013
     timed out */
593
1014
  
594
 
  switch (event) {
 
1015
  if(quit_now){
 
1016
    return;
 
1017
  }
 
1018
  
 
1019
  switch(event){
595
1020
  default:
596
1021
  case AVAHI_RESOLVER_FAILURE:
597
 
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
598
 
            " type '%s' in domain '%s': %s\n", name, type, domain,
599
 
            avahi_strerror(avahi_server_errno(mc->server)));
 
1022
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
 
1023
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
 
1024
                 domain,
 
1025
                 avahi_strerror(avahi_server_errno(mc.server)));
600
1026
    break;
601
1027
    
602
1028
  case AVAHI_RESOLVER_FOUND:
604
1030
      char ip[AVAHI_ADDRESS_STR_MAX];
605
1031
      avahi_address_snprint(ip, sizeof(ip), address);
606
1032
      if(debug){
607
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
608
 
                " port %d\n", name, host_name, ip, port);
 
1033
        fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
1034
                     PRIdMAX ") on port %" PRIu16 "\n", name,
 
1035
                     host_name, ip, (intmax_t)interface, port);
609
1036
      }
610
 
      int ret = start_mandos_communication(ip, port, interface, mc);
611
 
      if (ret == 0){
612
 
        exit(EXIT_SUCCESS);
 
1037
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1038
                                           interface,
 
1039
                                           avahi_proto_to_af(proto));
 
1040
      if(ret == 0){
 
1041
        avahi_simple_poll_quit(mc.simple_poll);
 
1042
      } else {
 
1043
        if(not add_server(ip, (in_port_t)port, interface,
 
1044
                          avahi_proto_to_af(proto))){
 
1045
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1046
                       " list\n", name);
 
1047
        }
613
1048
      }
614
1049
    }
615
1050
  }
616
1051
  avahi_s_service_resolver_free(r);
617
1052
}
618
1053
 
619
 
static void browse_callback( AvahiSServiceBrowser *b,
620
 
                             AvahiIfIndex interface,
621
 
                             AvahiProtocol protocol,
622
 
                             AvahiBrowserEvent event,
623
 
                             const char *name,
624
 
                             const char *type,
625
 
                             const char *domain,
626
 
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
627
 
                             void* userdata) {
628
 
  mandos_context *mc = userdata;
629
 
  assert(b);                    /* Spurious warning */
 
1054
static void browse_callback(AvahiSServiceBrowser *b,
 
1055
                            AvahiIfIndex interface,
 
1056
                            AvahiProtocol protocol,
 
1057
                            AvahiBrowserEvent event,
 
1058
                            const char *name,
 
1059
                            const char *type,
 
1060
                            const char *domain,
 
1061
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
1062
                            flags,
 
1063
                            AVAHI_GCC_UNUSED void* userdata){
 
1064
  if(b == NULL){
 
1065
    return;
 
1066
  }
630
1067
  
631
1068
  /* Called whenever a new services becomes available on the LAN or
632
1069
     is removed from the LAN */
633
1070
  
634
 
  switch (event) {
 
1071
  if(quit_now){
 
1072
    return;
 
1073
  }
 
1074
  
 
1075
  switch(event){
635
1076
  default:
636
1077
  case AVAHI_BROWSER_FAILURE:
637
 
      
638
 
    fprintf(stderr, "(Browser) %s\n",
639
 
            avahi_strerror(avahi_server_errno(mc->server)));
640
 
    avahi_simple_poll_quit(mc->simple_poll);
 
1078
    
 
1079
    fprintf_plus(stderr, "(Avahi browser) %s\n",
 
1080
                 avahi_strerror(avahi_server_errno(mc.server)));
 
1081
    avahi_simple_poll_quit(mc.simple_poll);
641
1082
    return;
642
 
      
 
1083
    
643
1084
  case AVAHI_BROWSER_NEW:
644
 
    /* We ignore the returned resolver object. In the callback
645
 
       function we free it. If the server is terminated before
646
 
       the callback function is called the server will free
647
 
       the resolver for us. */
648
 
      
649
 
    if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
650
 
                                       type, domain,
651
 
                                       AVAHI_PROTO_INET6, 0,
652
 
                                       resolve_callback, mc)))
653
 
      fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
654
 
              avahi_strerror(avahi_server_errno(s)));
 
1085
    /* We ignore the returned Avahi resolver object. In the callback
 
1086
       function we free it. If the Avahi server is terminated before
 
1087
       the callback function is called the Avahi server will free the
 
1088
       resolver for us. */
 
1089
    
 
1090
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
 
1091
                                    name, type, domain, protocol, 0,
 
1092
                                    resolve_callback, NULL) == NULL)
 
1093
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
 
1094
                   " %s\n", name,
 
1095
                   avahi_strerror(avahi_server_errno(mc.server)));
655
1096
    break;
656
 
      
 
1097
    
657
1098
  case AVAHI_BROWSER_REMOVE:
658
1099
    break;
659
 
      
 
1100
    
660
1101
  case AVAHI_BROWSER_ALL_FOR_NOW:
661
1102
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
1103
    if(debug){
 
1104
      fprintf_plus(stderr, "No Mandos server found, still"
 
1105
                   " searching...\n");
 
1106
    }
662
1107
    break;
663
1108
  }
664
1109
}
665
1110
 
666
 
/* Combines file name and path and returns the malloced new
667
 
   string. some sane checks could/should be added */
668
 
static const char *combinepath(const char *first, const char *second){
669
 
  size_t f_len = strlen(first);
670
 
  size_t s_len = strlen(second);
671
 
  char *tmp = malloc(f_len + s_len + 2);
672
 
  if (tmp == NULL){
673
 
    return NULL;
674
 
  }
675
 
  if(f_len > 0){
676
 
    memcpy(tmp, first, f_len);
677
 
  }
678
 
  tmp[f_len] = '/';
679
 
  if(s_len > 0){
680
 
    memcpy(tmp + f_len + 1, second, s_len);
681
 
  }
682
 
  tmp[f_len + 1 + s_len] = '\0';
683
 
  return tmp;
684
 
}
685
 
 
686
 
 
687
 
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
1111
/* Signal handler that stops main loop after SIGTERM */
 
1112
static void handle_sigterm(int sig){
 
1113
  if(quit_now){
 
1114
    return;
 
1115
  }
 
1116
  quit_now = 1;
 
1117
  signal_received = sig;
 
1118
  int old_errno = errno;
 
1119
  /* set main loop to exit */
 
1120
  if(mc.simple_poll != NULL){
 
1121
    avahi_simple_poll_quit(mc.simple_poll);
 
1122
  }
 
1123
  errno = old_errno;
 
1124
}
 
1125
 
 
1126
bool get_flags(const char *ifname, struct ifreq *ifr){
 
1127
  int ret;
 
1128
  error_t ret_errno;
 
1129
  
 
1130
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1131
  if(s < 0){
 
1132
    ret_errno = errno;
 
1133
    perror_plus("socket");
 
1134
    errno = ret_errno;
 
1135
    return false;
 
1136
  }
 
1137
  strcpy(ifr->ifr_name, ifname);
 
1138
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
 
1139
  if(ret == -1){
 
1140
    if(debug){
 
1141
      ret_errno = errno;
 
1142
      perror_plus("ioctl SIOCGIFFLAGS");
 
1143
      errno = ret_errno;
 
1144
    }
 
1145
    return false;
 
1146
  }
 
1147
  return true;
 
1148
}
 
1149
 
 
1150
bool good_flags(const char *ifname, const struct ifreq *ifr){
 
1151
  
 
1152
  /* Reject the loopback device */
 
1153
  if(ifr->ifr_flags & IFF_LOOPBACK){
 
1154
    if(debug){
 
1155
      fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
 
1156
                   ifname);
 
1157
    }
 
1158
    return false;
 
1159
  }
 
1160
  /* Accept point-to-point devices only if connect_to is specified */
 
1161
  if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
 
1162
    if(debug){
 
1163
      fprintf_plus(stderr, "Accepting point-to-point interface"
 
1164
                   " \"%s\"\n", ifname);
 
1165
    }
 
1166
    return true;
 
1167
  }
 
1168
  /* Otherwise, reject non-broadcast-capable devices */
 
1169
  if(not (ifr->ifr_flags & IFF_BROADCAST)){
 
1170
    if(debug){
 
1171
      fprintf_plus(stderr, "Rejecting non-broadcast interface"
 
1172
                   " \"%s\"\n", ifname);
 
1173
    }
 
1174
    return false;
 
1175
  }
 
1176
  /* Reject non-ARP interfaces (including dummy interfaces) */
 
1177
  if(ifr->ifr_flags & IFF_NOARP){
 
1178
    if(debug){
 
1179
      fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
 
1180
                   ifname);
 
1181
    }
 
1182
    return false;
 
1183
  }
 
1184
  
 
1185
  /* Accept this device */
 
1186
  if(debug){
 
1187
    fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
 
1188
  }
 
1189
  return true;
 
1190
}
 
1191
 
 
1192
/* 
 
1193
 * This function determines if a directory entry in /sys/class/net
 
1194
 * corresponds to an acceptable network device.
 
1195
 * (This function is passed to scandir(3) as a filter function.)
 
1196
 */
 
1197
int good_interface(const struct dirent *if_entry){
 
1198
  if(if_entry->d_name[0] == '.'){
 
1199
    return 0;
 
1200
  }
 
1201
  
 
1202
  struct ifreq ifr;
 
1203
  if(not get_flags(if_entry->d_name, &ifr)){
 
1204
    if(debug){
 
1205
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1206
                   "\"%s\"\n", if_entry->d_name);
 
1207
    }
 
1208
    return 0;
 
1209
  }
 
1210
  
 
1211
  if(not good_flags(if_entry->d_name, &ifr)){
 
1212
    return 0;
 
1213
  }
 
1214
  return 1;
 
1215
}
 
1216
 
 
1217
/* 
 
1218
 * This function determines if a network interface is up.
 
1219
 */
 
1220
bool interface_is_up(const char *interface){
 
1221
  struct ifreq ifr;
 
1222
  if(not get_flags(interface, &ifr)){
 
1223
    if(debug){
 
1224
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1225
                   "\"%s\"\n", interface);
 
1226
    }
 
1227
    return false;
 
1228
  }
 
1229
  
 
1230
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1231
}
 
1232
 
 
1233
/* 
 
1234
 * This function determines if a network interface is running
 
1235
 */
 
1236
bool interface_is_running(const char *interface){
 
1237
  struct ifreq ifr;
 
1238
  if(not get_flags(interface, &ifr)){
 
1239
    if(debug){
 
1240
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1241
                   "\"%s\"\n", interface);
 
1242
    }
 
1243
    return false;
 
1244
  }
 
1245
  
 
1246
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1247
}
 
1248
 
 
1249
int notdotentries(const struct dirent *direntry){
 
1250
  /* Skip "." and ".." */
 
1251
  if(direntry->d_name[0] == '.'
 
1252
     and (direntry->d_name[1] == '\0'
 
1253
          or (direntry->d_name[1] == '.'
 
1254
              and direntry->d_name[2] == '\0'))){
 
1255
    return 0;
 
1256
  }
 
1257
  return 1;
 
1258
}
 
1259
 
 
1260
/* Is this directory entry a runnable program? */
 
1261
int runnable_hook(const struct dirent *direntry){
 
1262
  int ret;
 
1263
  size_t sret;
 
1264
  struct stat st;
 
1265
  
 
1266
  if((direntry->d_name)[0] == '\0'){
 
1267
    /* Empty name? */
 
1268
    return 0;
 
1269
  }
 
1270
  
 
1271
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
1272
                "abcdefghijklmnopqrstuvwxyz"
 
1273
                "0123456789"
 
1274
                "_-");
 
1275
  if((direntry->d_name)[sret] != '\0'){
 
1276
    /* Contains non-allowed characters */
 
1277
    if(debug){
 
1278
      fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
 
1279
                   direntry->d_name);
 
1280
    }
 
1281
    return 0;
 
1282
  }
 
1283
  
 
1284
  char *fullname = NULL;
 
1285
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
 
1286
  if(ret < 0){
 
1287
    perror_plus("asprintf");
 
1288
    return 0;
 
1289
  }
 
1290
  
 
1291
  ret = stat(fullname, &st);
 
1292
  if(ret == -1){
 
1293
    if(debug){
 
1294
      perror_plus("Could not stat hook");
 
1295
    }
 
1296
    return 0;
 
1297
  }
 
1298
  if(not (S_ISREG(st.st_mode))){
 
1299
    /* Not a regular file */
 
1300
    if(debug){
 
1301
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
 
1302
                   direntry->d_name);
 
1303
    }
 
1304
    return 0;
 
1305
  }
 
1306
  if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
 
1307
    /* Not executable */
 
1308
    if(debug){
 
1309
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
 
1310
                   direntry->d_name);
 
1311
    }
 
1312
    return 0;
 
1313
  }
 
1314
  if(debug){
 
1315
    fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
 
1316
                 direntry->d_name);
 
1317
  }
 
1318
  return 1;
 
1319
}
 
1320
 
 
1321
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1322
  int ret;
 
1323
  struct timespec now;
 
1324
  struct timespec waited_time;
 
1325
  intmax_t block_time;
 
1326
  
 
1327
  while(true){
 
1328
    if(mc.current_server == NULL){
 
1329
      if (debug){
 
1330
        fprintf_plus(stderr, "Wait until first server is found."
 
1331
                     " No timeout!\n");
 
1332
      }
 
1333
      ret = avahi_simple_poll_iterate(s, -1);
 
1334
    } else {
 
1335
      if (debug){
 
1336
        fprintf_plus(stderr, "Check current_server if we should run"
 
1337
                     " it, or wait\n");
 
1338
      }
 
1339
      /* the current time */
 
1340
      ret = clock_gettime(CLOCK_MONOTONIC, &now);
 
1341
      if(ret == -1){
 
1342
        perror_plus("clock_gettime");
 
1343
        return -1;
 
1344
      }
 
1345
      /* Calculating in ms how long time between now and server
 
1346
         who we visted longest time ago. Now - last seen.  */
 
1347
      waited_time.tv_sec = (now.tv_sec
 
1348
                            - mc.current_server->last_seen.tv_sec);
 
1349
      waited_time.tv_nsec = (now.tv_nsec
 
1350
                             - mc.current_server->last_seen.tv_nsec);
 
1351
      /* total time is 10s/10,000ms.
 
1352
         Converting to s from ms by dividing by 1,000,
 
1353
         and ns to ms by dividing by 1,000,000. */
 
1354
      block_time = ((retry_interval
 
1355
                     - ((intmax_t)waited_time.tv_sec * 1000))
 
1356
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
 
1357
      
 
1358
      if (debug){
 
1359
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
 
1360
                     block_time);
 
1361
      }
 
1362
      
 
1363
      if(block_time <= 0){
 
1364
        ret = start_mandos_communication(mc.current_server->ip,
 
1365
                                         mc.current_server->port,
 
1366
                                         mc.current_server->if_index,
 
1367
                                         mc.current_server->af);
 
1368
        if(ret == 0){
 
1369
          avahi_simple_poll_quit(mc.simple_poll);
 
1370
          return 0;
 
1371
        }
 
1372
        ret = clock_gettime(CLOCK_MONOTONIC,
 
1373
                            &mc.current_server->last_seen);
 
1374
        if(ret == -1){
 
1375
          perror_plus("clock_gettime");
 
1376
          return -1;
 
1377
        }
 
1378
        mc.current_server = mc.current_server->next;
 
1379
        block_time = 0;         /* Call avahi to find new Mandos
 
1380
                                   servers, but don't block */
 
1381
      }
 
1382
      
 
1383
      ret = avahi_simple_poll_iterate(s, (int)block_time);
 
1384
    }
 
1385
    if(ret != 0){
 
1386
      if (ret > 0 or errno != EINTR){
 
1387
        return (ret != 1) ? ret : 0;
 
1388
      }
 
1389
    }
 
1390
  }
 
1391
}
 
1392
 
 
1393
/* Set effective uid to 0, return errno */
 
1394
error_t raise_privileges(void){
 
1395
  error_t old_errno = errno;
 
1396
  error_t ret_errno = 0;
 
1397
  if(seteuid(0) == -1){
 
1398
    ret_errno = errno;
 
1399
    perror_plus("seteuid");
 
1400
  }
 
1401
  errno = old_errno;
 
1402
  return ret_errno;
 
1403
}
 
1404
 
 
1405
/* Set effective and real user ID to 0.  Return errno. */
 
1406
error_t raise_privileges_permanently(void){
 
1407
  error_t old_errno = errno;
 
1408
  error_t ret_errno = raise_privileges();
 
1409
  if(ret_errno != 0){
 
1410
    errno = old_errno;
 
1411
    return ret_errno;
 
1412
  }
 
1413
  if(setuid(0) == -1){
 
1414
    ret_errno = errno;
 
1415
    perror_plus("seteuid");
 
1416
  }
 
1417
  errno = old_errno;
 
1418
  return ret_errno;
 
1419
}
 
1420
 
 
1421
/* Set effective user ID to unprivileged saved user ID */
 
1422
error_t lower_privileges(void){
 
1423
  error_t old_errno = errno;
 
1424
  error_t ret_errno = 0;
 
1425
  if(seteuid(uid) == -1){
 
1426
    ret_errno = errno;
 
1427
    perror_plus("seteuid");
 
1428
  }
 
1429
  errno = old_errno;
 
1430
  return ret_errno;
 
1431
}
 
1432
 
 
1433
/* Lower privileges permanently */
 
1434
error_t lower_privileges_permanently(void){
 
1435
  error_t old_errno = errno;
 
1436
  error_t ret_errno = 0;
 
1437
  if(setuid(uid) == -1){
 
1438
    ret_errno = errno;
 
1439
    perror_plus("setuid");
 
1440
  }
 
1441
  errno = old_errno;
 
1442
  return ret_errno;
 
1443
}
 
1444
 
 
1445
bool run_network_hooks(const char *mode, const char *interface,
 
1446
                       const float delay){
 
1447
  struct dirent **direntries;
 
1448
  struct dirent *direntry;
 
1449
  int ret;
 
1450
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1451
                         alphasort);
 
1452
  if(numhooks == -1){
 
1453
    if(errno == ENOENT){
 
1454
      if(debug){
 
1455
        fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1456
                     " found\n", hookdir);
 
1457
      }
 
1458
    } else {
 
1459
      perror_plus("scandir");
 
1460
    }
 
1461
  } else {
 
1462
    int devnull = open("/dev/null", O_RDONLY);
 
1463
    for(int i = 0; i < numhooks; i++){
 
1464
      direntry = direntries[i];
 
1465
      char *fullname = NULL;
 
1466
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
 
1467
      if(ret < 0){
 
1468
        perror_plus("asprintf");
 
1469
        continue;
 
1470
      }
 
1471
      if(debug){
 
1472
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1473
                     direntry->d_name);
 
1474
      }
 
1475
      pid_t hook_pid = fork();
 
1476
      if(hook_pid == 0){
 
1477
        /* Child */
 
1478
        /* Raise privileges */
 
1479
        raise_privileges_permanently();
 
1480
        /* Set group */
 
1481
        errno = 0;
 
1482
        ret = setgid(0);
 
1483
        if(ret == -1){
 
1484
          perror_plus("setgid");
 
1485
        }
 
1486
        /* Reset supplementary groups */
 
1487
        errno = 0;
 
1488
        ret = setgroups(0, NULL);
 
1489
        if(ret == -1){
 
1490
          perror_plus("setgroups");
 
1491
        }
 
1492
        dup2(devnull, STDIN_FILENO);
 
1493
        close(devnull);
 
1494
        dup2(STDERR_FILENO, STDOUT_FILENO);
 
1495
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1496
        if(ret == -1){
 
1497
          perror_plus("setenv");
 
1498
          _exit(EX_OSERR);
 
1499
        }
 
1500
        ret = setenv("DEVICE", interface, 1);
 
1501
        if(ret == -1){
 
1502
          perror_plus("setenv");
 
1503
          _exit(EX_OSERR);
 
1504
        }
 
1505
        ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1506
        if(ret == -1){
 
1507
          perror_plus("setenv");
 
1508
          _exit(EX_OSERR);
 
1509
        }
 
1510
        ret = setenv("MODE", mode, 1);
 
1511
        if(ret == -1){
 
1512
          perror_plus("setenv");
 
1513
          _exit(EX_OSERR);
 
1514
        }
 
1515
        char *delaystring;
 
1516
        ret = asprintf(&delaystring, "%f", delay);
 
1517
        if(ret == -1){
 
1518
          perror_plus("asprintf");
 
1519
          _exit(EX_OSERR);
 
1520
        }
 
1521
        ret = setenv("DELAY", delaystring, 1);
 
1522
        if(ret == -1){
 
1523
          free(delaystring);
 
1524
          perror_plus("setenv");
 
1525
          _exit(EX_OSERR);
 
1526
        }
 
1527
        free(delaystring);
 
1528
        if(connect_to != NULL){
 
1529
          ret = setenv("CONNECT", connect_to, 1);
 
1530
          if(ret == -1){
 
1531
            perror_plus("setenv");
 
1532
            _exit(EX_OSERR);
 
1533
          }
 
1534
        }
 
1535
        if(execl(fullname, direntry->d_name, mode, NULL) == -1){
 
1536
          perror_plus("execl");
 
1537
          _exit(EXIT_FAILURE);
 
1538
        }
 
1539
      } else {
 
1540
        int status;
 
1541
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
1542
          perror_plus("waitpid");
 
1543
          free(fullname);
 
1544
          continue;
 
1545
        }
 
1546
        if(WIFEXITED(status)){
 
1547
          if(WEXITSTATUS(status) != 0){
 
1548
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
1549
                         " with status %d\n", direntry->d_name,
 
1550
                         WEXITSTATUS(status));
 
1551
            free(fullname);
 
1552
            continue;
 
1553
          }
 
1554
        } else if(WIFSIGNALED(status)){
 
1555
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
1556
                       " signal %d\n", direntry->d_name,
 
1557
                       WTERMSIG(status));
 
1558
          free(fullname);
 
1559
          continue;
 
1560
        } else {
 
1561
          fprintf_plus(stderr, "Warning: network hook \"%s\""
 
1562
                       " crashed\n", direntry->d_name);
 
1563
          free(fullname);
 
1564
          continue;
 
1565
        }
 
1566
      }
 
1567
      free(fullname);
 
1568
      if(debug){
 
1569
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
1570
                     direntry->d_name);
 
1571
      }
 
1572
    }
 
1573
    close(devnull);
 
1574
  }
 
1575
  return true;
 
1576
}
 
1577
 
 
1578
error_t bring_up_interface(const char *const interface,
 
1579
                           const float delay){
 
1580
  int sd = -1;
 
1581
  error_t old_errno = errno;
 
1582
  error_t ret_errno = 0;
 
1583
  int ret, ret_setflags;
 
1584
  struct ifreq network;
 
1585
  unsigned int if_index = if_nametoindex(interface);
 
1586
  if(if_index == 0){
 
1587
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1588
    errno = old_errno;
 
1589
    return ENXIO;
 
1590
  }
 
1591
  
 
1592
  if(quit_now){
 
1593
    errno = old_errno;
 
1594
    return EINTR;
 
1595
  }
 
1596
  
 
1597
  if(not interface_is_up(interface)){
 
1598
    if(not get_flags(interface, &network) and debug){
 
1599
      ret_errno = errno;
 
1600
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1601
                   "\"%s\"\n", interface);
 
1602
      return ret_errno;
 
1603
    }
 
1604
    network.ifr_flags |= IFF_UP;
 
1605
    
 
1606
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1607
    if(sd < 0){
 
1608
      ret_errno = errno;
 
1609
      perror_plus("socket");
 
1610
      errno = old_errno;
 
1611
      return ret_errno;
 
1612
    }
 
1613
  
 
1614
    if(quit_now){
 
1615
      close(sd);
 
1616
      errno = old_errno;
 
1617
      return EINTR;
 
1618
    }
 
1619
    
 
1620
    if(debug){
 
1621
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
1622
                   interface);
 
1623
    }
 
1624
    
 
1625
    /* Raise priviliges */
 
1626
    raise_privileges();
 
1627
    
 
1628
#ifdef __linux__
 
1629
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1630
       messages about the network interface to mess up the prompt */
 
1631
    int ret_linux = klogctl(8, NULL, 5);
 
1632
    bool restore_loglevel = true;
 
1633
    if(ret_linux == -1){
 
1634
      restore_loglevel = false;
 
1635
      perror_plus("klogctl");
 
1636
    }
 
1637
#endif  /* __linux__ */
 
1638
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1639
    ret_errno = errno;
 
1640
#ifdef __linux__
 
1641
    if(restore_loglevel){
 
1642
      ret_linux = klogctl(7, NULL, 0);
 
1643
      if(ret_linux == -1){
 
1644
        perror_plus("klogctl");
 
1645
      }
 
1646
    }
 
1647
#endif  /* __linux__ */
 
1648
    
 
1649
    /* Lower privileges */
 
1650
    lower_privileges();
 
1651
    
 
1652
    /* Close the socket */
 
1653
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1654
    if(ret == -1){
 
1655
      perror_plus("close");
 
1656
    }
 
1657
    
 
1658
    if(ret_setflags == -1){
 
1659
      errno = ret_errno;
 
1660
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
1661
      errno = old_errno;
 
1662
      return ret_errno;
 
1663
    }
 
1664
  } else if(debug){
 
1665
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
1666
                 interface);
 
1667
  }
 
1668
  
 
1669
  /* Sleep checking until interface is running.
 
1670
     Check every 0.25s, up to total time of delay */
 
1671
  for(int i=0; i < delay * 4; i++){
 
1672
    if(interface_is_running(interface)){
 
1673
      break;
 
1674
    }
 
1675
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1676
    ret = nanosleep(&sleeptime, NULL);
 
1677
    if(ret == -1 and errno != EINTR){
 
1678
      perror_plus("nanosleep");
 
1679
    }
 
1680
  }
 
1681
  
 
1682
  errno = old_errno;
 
1683
  return 0;
 
1684
}
 
1685
 
 
1686
error_t take_down_interface(const char *const interface){
 
1687
  int sd = -1;
 
1688
  error_t old_errno = errno;
 
1689
  error_t ret_errno = 0;
 
1690
  int ret, ret_setflags;
 
1691
  struct ifreq network;
 
1692
  unsigned int if_index = if_nametoindex(interface);
 
1693
  if(if_index == 0){
 
1694
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1695
    errno = old_errno;
 
1696
    return ENXIO;
 
1697
  }
 
1698
  if(interface_is_up(interface)){
 
1699
    if(not get_flags(interface, &network) and debug){
 
1700
      ret_errno = errno;
 
1701
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1702
                   "\"%s\"\n", interface);
 
1703
      return ret_errno;
 
1704
    }
 
1705
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1706
    
 
1707
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1708
    if(sd < 0){
 
1709
      ret_errno = errno;
 
1710
      perror_plus("socket");
 
1711
      errno = old_errno;
 
1712
      return ret_errno;
 
1713
    }
 
1714
    
 
1715
    if(debug){
 
1716
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
1717
                   interface);
 
1718
    }
 
1719
    
 
1720
    /* Raise priviliges */
 
1721
    raise_privileges();
 
1722
    
 
1723
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1724
    ret_errno = errno;
 
1725
    
 
1726
    /* Lower privileges */
 
1727
    lower_privileges();
 
1728
    
 
1729
    /* Close the socket */
 
1730
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1731
    if(ret == -1){
 
1732
      perror_plus("close");
 
1733
    }
 
1734
    
 
1735
    if(ret_setflags == -1){
 
1736
      errno = ret_errno;
 
1737
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1738
      errno = old_errno;
 
1739
      return ret_errno;
 
1740
    }
 
1741
  } else if(debug){
 
1742
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
1743
                 interface);
 
1744
  }
 
1745
  
 
1746
  errno = old_errno;
 
1747
  return 0;
 
1748
}
 
1749
 
 
1750
int main(int argc, char *argv[]){
 
1751
  AvahiSServiceBrowser *sb = NULL;
 
1752
  error_t ret_errno;
 
1753
  int ret;
 
1754
  intmax_t tmpmax;
 
1755
  char *tmp;
 
1756
  int exitcode = EXIT_SUCCESS;
 
1757
  char *interfaces = NULL;
 
1758
  size_t interfaces_size = 0;
 
1759
  char *interfaces_to_take_down = NULL;
 
1760
  size_t interfaces_to_take_down_size = 0;
 
1761
  char tempdir[] = "/tmp/mandosXXXXXX";
 
1762
  bool tempdir_created = false;
 
1763
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
1764
  const char *seckey = PATHDIR "/" SECKEY;
 
1765
  const char *pubkey = PATHDIR "/" PUBKEY;
 
1766
  char *interfaces_hooks = NULL;
 
1767
  size_t interfaces_hooks_size = 0;
 
1768
  
 
1769
  bool gnutls_initialized = false;
 
1770
  bool gpgme_initialized = false;
 
1771
  float delay = 2.5f;
 
1772
  double retry_interval = 10; /* 10s between trying a server and
 
1773
                                 retrying the same server again */
 
1774
  
 
1775
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
 
1776
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
 
1777
  
 
1778
  uid = getuid();
 
1779
  gid = getgid();
 
1780
  
 
1781
  /* Lower any group privileges we might have, just to be safe */
 
1782
  errno = 0;
 
1783
  ret = setgid(gid);
 
1784
  if(ret == -1){
 
1785
    perror_plus("setgid");
 
1786
  }
 
1787
  
 
1788
  /* Lower user privileges (temporarily) */
 
1789
  errno = 0;
 
1790
  ret = seteuid(uid);
 
1791
  if(ret == -1){
 
1792
    perror_plus("seteuid");
 
1793
  }
 
1794
  
 
1795
  if(quit_now){
 
1796
    goto end;
 
1797
  }
 
1798
  
 
1799
  {
 
1800
    struct argp_option options[] = {
 
1801
      { .name = "debug", .key = 128,
 
1802
        .doc = "Debug mode", .group = 3 },
 
1803
      { .name = "connect", .key = 'c',
 
1804
        .arg = "ADDRESS:PORT",
 
1805
        .doc = "Connect directly to a specific Mandos server",
 
1806
        .group = 1 },
 
1807
      { .name = "interface", .key = 'i',
 
1808
        .arg = "NAME",
 
1809
        .doc = "Network interface that will be used to search for"
 
1810
        " Mandos servers",
 
1811
        .group = 1 },
 
1812
      { .name = "seckey", .key = 's',
 
1813
        .arg = "FILE",
 
1814
        .doc = "OpenPGP secret key file base name",
 
1815
        .group = 1 },
 
1816
      { .name = "pubkey", .key = 'p',
 
1817
        .arg = "FILE",
 
1818
        .doc = "OpenPGP public key file base name",
 
1819
        .group = 2 },
 
1820
      { .name = "dh-bits", .key = 129,
 
1821
        .arg = "BITS",
 
1822
        .doc = "Bit length of the prime number used in the"
 
1823
        " Diffie-Hellman key exchange",
 
1824
        .group = 2 },
 
1825
      { .name = "priority", .key = 130,
 
1826
        .arg = "STRING",
 
1827
        .doc = "GnuTLS priority string for the TLS handshake",
 
1828
        .group = 1 },
 
1829
      { .name = "delay", .key = 131,
 
1830
        .arg = "SECONDS",
 
1831
        .doc = "Maximum delay to wait for interface startup",
 
1832
        .group = 2 },
 
1833
      { .name = "retry", .key = 132,
 
1834
        .arg = "SECONDS",
 
1835
        .doc = "Retry interval used when denied by the Mandos server",
 
1836
        .group = 2 },
 
1837
      { .name = "network-hook-dir", .key = 133,
 
1838
        .arg = "DIR",
 
1839
        .doc = "Directory where network hooks are located",
 
1840
        .group = 2 },
 
1841
      /*
 
1842
       * These reproduce what we would get without ARGP_NO_HELP
 
1843
       */
 
1844
      { .name = "help", .key = '?',
 
1845
        .doc = "Give this help list", .group = -1 },
 
1846
      { .name = "usage", .key = -3,
 
1847
        .doc = "Give a short usage message", .group = -1 },
 
1848
      { .name = "version", .key = 'V',
 
1849
        .doc = "Print program version", .group = -1 },
 
1850
      { .name = NULL }
 
1851
    };
 
1852
    
 
1853
    error_t parse_opt(int key, char *arg,
 
1854
                      struct argp_state *state){
 
1855
      errno = 0;
 
1856
      switch(key){
 
1857
      case 128:                 /* --debug */
 
1858
        debug = true;
 
1859
        break;
 
1860
      case 'c':                 /* --connect */
 
1861
        connect_to = arg;
 
1862
        break;
 
1863
      case 'i':                 /* --interface */
 
1864
        ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
 
1865
                                 (int)',');
 
1866
        if(ret_errno != 0){
 
1867
          argp_error(state, "%s", strerror(ret_errno));
 
1868
        }
 
1869
        break;
 
1870
      case 's':                 /* --seckey */
 
1871
        seckey = arg;
 
1872
        break;
 
1873
      case 'p':                 /* --pubkey */
 
1874
        pubkey = arg;
 
1875
        break;
 
1876
      case 129:                 /* --dh-bits */
 
1877
        errno = 0;
 
1878
        tmpmax = strtoimax(arg, &tmp, 10);
 
1879
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1880
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
 
1881
          argp_error(state, "Bad number of DH bits");
 
1882
        }
 
1883
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
 
1884
        break;
 
1885
      case 130:                 /* --priority */
 
1886
        mc.priority = arg;
 
1887
        break;
 
1888
      case 131:                 /* --delay */
 
1889
        errno = 0;
 
1890
        delay = strtof(arg, &tmp);
 
1891
        if(errno != 0 or tmp == arg or *tmp != '\0'){
 
1892
          argp_error(state, "Bad delay");
 
1893
        }
 
1894
      case 132:                 /* --retry */
 
1895
        errno = 0;
 
1896
        retry_interval = strtod(arg, &tmp);
 
1897
        if(errno != 0 or tmp == arg or *tmp != '\0'
 
1898
           or (retry_interval * 1000) > INT_MAX
 
1899
           or retry_interval < 0){
 
1900
          argp_error(state, "Bad retry interval");
 
1901
        }
 
1902
        break;
 
1903
      case 133:                 /* --network-hook-dir */
 
1904
        hookdir = arg;
 
1905
        break;
 
1906
        /*
 
1907
         * These reproduce what we would get without ARGP_NO_HELP
 
1908
         */
 
1909
      case '?':                 /* --help */
 
1910
        argp_state_help(state, state->out_stream,
 
1911
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
 
1912
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
1913
      case -3:                  /* --usage */
 
1914
        argp_state_help(state, state->out_stream,
 
1915
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
1916
      case 'V':                 /* --version */
 
1917
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
 
1918
        exit(argp_err_exit_status);
 
1919
        break;
 
1920
      default:
 
1921
        return ARGP_ERR_UNKNOWN;
 
1922
      }
 
1923
      return errno;
 
1924
    }
 
1925
    
 
1926
    struct argp argp = { .options = options, .parser = parse_opt,
 
1927
                         .args_doc = "",
 
1928
                         .doc = "Mandos client -- Get and decrypt"
 
1929
                         " passwords from a Mandos server" };
 
1930
    ret = argp_parse(&argp, argc, argv,
 
1931
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
1932
    switch(ret){
 
1933
    case 0:
 
1934
      break;
 
1935
    case ENOMEM:
 
1936
    default:
 
1937
      errno = ret;
 
1938
      perror_plus("argp_parse");
 
1939
      exitcode = EX_OSERR;
 
1940
      goto end;
 
1941
    case EINVAL:
 
1942
      exitcode = EX_USAGE;
 
1943
      goto end;
 
1944
    }
 
1945
  }
 
1946
    
 
1947
  {
 
1948
    /* Work around Debian bug #633582:
 
1949
       <http://bugs.debian.org/633582> */
 
1950
    
 
1951
    /* Re-raise priviliges */
 
1952
    if(raise_privileges() == 0){
 
1953
      struct stat st;
 
1954
      
 
1955
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
1956
        int seckey_fd = open(seckey, O_RDONLY);
 
1957
        if(seckey_fd == -1){
 
1958
          perror_plus("open");
 
1959
        } else {
 
1960
          ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
1961
          if(ret == -1){
 
1962
            perror_plus("fstat");
 
1963
          } else {
 
1964
            if(S_ISREG(st.st_mode)
 
1965
               and st.st_uid == 0 and st.st_gid == 0){
 
1966
              ret = fchown(seckey_fd, uid, gid);
 
1967
              if(ret == -1){
 
1968
                perror_plus("fchown");
 
1969
              }
 
1970
            }
 
1971
          }
 
1972
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
1973
        }
 
1974
      }
 
1975
    
 
1976
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
1977
        int pubkey_fd = open(pubkey, O_RDONLY);
 
1978
        if(pubkey_fd == -1){
 
1979
          perror_plus("open");
 
1980
        } else {
 
1981
          ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
1982
          if(ret == -1){
 
1983
            perror_plus("fstat");
 
1984
          } else {
 
1985
            if(S_ISREG(st.st_mode)
 
1986
               and st.st_uid == 0 and st.st_gid == 0){
 
1987
              ret = fchown(pubkey_fd, uid, gid);
 
1988
              if(ret == -1){
 
1989
                perror_plus("fchown");
 
1990
              }
 
1991
            }
 
1992
          }
 
1993
          TEMP_FAILURE_RETRY(close(pubkey_fd));
 
1994
        }
 
1995
      }
 
1996
    
 
1997
      /* Lower privileges */
 
1998
      errno = 0;
 
1999
      ret = seteuid(uid);
 
2000
      if(ret == -1){
 
2001
        perror_plus("seteuid");
 
2002
      }
 
2003
    }
 
2004
  }
 
2005
  
 
2006
  /* Remove empty interface names */
 
2007
  {
 
2008
    char *interface = NULL;
 
2009
    while((interface = argz_next(interfaces, interfaces_size,
 
2010
                                 interface))){
 
2011
      if(if_nametoindex(interface) == 0){
 
2012
        if(interface[0] != '\0' and strcmp(interface, "none") != 0){
 
2013
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2014
                       " \"%s\"\n", interface);
 
2015
        }
 
2016
        argz_delete(&interfaces, &interfaces_size, interface);
 
2017
        interface = NULL;
 
2018
      }
 
2019
    }
 
2020
  }
 
2021
  
 
2022
  /* Run network hooks */
 
2023
  {
 
2024
    
 
2025
    if(interfaces != NULL){
 
2026
      interfaces_hooks = malloc(interfaces_size);
 
2027
      if(interfaces_hooks == NULL){
 
2028
        perror_plus("malloc");
 
2029
        goto end;
 
2030
      }
 
2031
      memcpy(interfaces_hooks, interfaces, interfaces_size);
 
2032
      interfaces_hooks_size = interfaces_size;
 
2033
      argz_stringify(interfaces_hooks, interfaces_hooks_size,
 
2034
                     (int)',');
 
2035
    }
 
2036
    if(not run_network_hooks("start", interfaces_hooks != NULL ?
 
2037
                             interfaces_hooks : "", delay)){
 
2038
      goto end;
 
2039
    }
 
2040
  }
 
2041
  
 
2042
  if(not debug){
 
2043
    avahi_set_log_function(empty_log);
 
2044
  }
 
2045
  
 
2046
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
 
2047
     from the signal handler */
 
2048
  /* Initialize the pseudo-RNG for Avahi */
 
2049
  srand((unsigned int) time(NULL));
 
2050
  mc.simple_poll = avahi_simple_poll_new();
 
2051
  if(mc.simple_poll == NULL){
 
2052
    fprintf_plus(stderr,
 
2053
                 "Avahi: Failed to create simple poll object.\n");
 
2054
    exitcode = EX_UNAVAILABLE;
 
2055
    goto end;
 
2056
  }
 
2057
  
 
2058
  sigemptyset(&sigterm_action.sa_mask);
 
2059
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
 
2060
  if(ret == -1){
 
2061
    perror_plus("sigaddset");
 
2062
    exitcode = EX_OSERR;
 
2063
    goto end;
 
2064
  }
 
2065
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
 
2066
  if(ret == -1){
 
2067
    perror_plus("sigaddset");
 
2068
    exitcode = EX_OSERR;
 
2069
    goto end;
 
2070
  }
 
2071
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
 
2072
  if(ret == -1){
 
2073
    perror_plus("sigaddset");
 
2074
    exitcode = EX_OSERR;
 
2075
    goto end;
 
2076
  }
 
2077
  /* Need to check if the handler is SIG_IGN before handling:
 
2078
     | [[info:libc:Initial Signal Actions]] |
 
2079
     | [[info:libc:Basic Signal Handling]]  |
 
2080
  */
 
2081
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
 
2082
  if(ret == -1){
 
2083
    perror_plus("sigaction");
 
2084
    return EX_OSERR;
 
2085
  }
 
2086
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
2087
    ret = sigaction(SIGINT, &sigterm_action, NULL);
 
2088
    if(ret == -1){
 
2089
      perror_plus("sigaction");
 
2090
      exitcode = EX_OSERR;
 
2091
      goto end;
 
2092
    }
 
2093
  }
 
2094
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
 
2095
  if(ret == -1){
 
2096
    perror_plus("sigaction");
 
2097
    return EX_OSERR;
 
2098
  }
 
2099
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
2100
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
 
2101
    if(ret == -1){
 
2102
      perror_plus("sigaction");
 
2103
      exitcode = EX_OSERR;
 
2104
      goto end;
 
2105
    }
 
2106
  }
 
2107
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
 
2108
  if(ret == -1){
 
2109
    perror_plus("sigaction");
 
2110
    return EX_OSERR;
 
2111
  }
 
2112
  if(old_sigterm_action.sa_handler != SIG_IGN){
 
2113
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
 
2114
    if(ret == -1){
 
2115
      perror_plus("sigaction");
 
2116
      exitcode = EX_OSERR;
 
2117
      goto end;
 
2118
    }
 
2119
  }
 
2120
  
 
2121
  /* If no interfaces were specified, make a list */
 
2122
  if(interfaces == NULL){
 
2123
    struct dirent **direntries;
 
2124
    /* Look for any good interfaces */
 
2125
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2126
                  alphasort);
 
2127
    if(ret >= 1){
 
2128
      /* Add all found interfaces to interfaces list */
 
2129
      for(int i = 0; i < ret; ++i){
 
2130
        ret_errno = argz_add(&interfaces, &interfaces_size,
 
2131
                             direntries[i]->d_name);
 
2132
        if(ret_errno != 0){
 
2133
          perror_plus("argz_add");
 
2134
          continue;
 
2135
        }
 
2136
        if(debug){
 
2137
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2138
                       direntries[i]->d_name);
 
2139
        }
 
2140
      }
 
2141
      free(direntries);
 
2142
    } else {
 
2143
      free(direntries);
 
2144
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2145
      exitcode = EXIT_FAILURE;
 
2146
      goto end;
 
2147
    }
 
2148
  }
 
2149
  
 
2150
  /* If we only got one interface, explicitly use only that one */
 
2151
  if(argz_count(interfaces, interfaces_size) == 1){
 
2152
    if(debug){
 
2153
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2154
                   interfaces);
 
2155
    }
 
2156
    if_index = (AvahiIfIndex)if_nametoindex(interfaces);
 
2157
  }
 
2158
  
 
2159
  /* Bring up interfaces which are down */
 
2160
  if(not (argz_count(interfaces, interfaces_size) == 1
 
2161
          and strcmp(interfaces, "none") == 0)){
 
2162
    char *interface = NULL;
 
2163
    while((interface = argz_next(interfaces, interfaces_size,
 
2164
                                 interface))){
 
2165
      bool interface_was_up = interface_is_up(interface);
 
2166
      ret = bring_up_interface(interface, delay);
 
2167
      if(not interface_was_up){
 
2168
        if(ret != 0){
 
2169
          errno = ret;
 
2170
          perror_plus("Failed to bring up interface");
 
2171
        } else {
 
2172
          ret_errno = argz_add(&interfaces_to_take_down,
 
2173
                               &interfaces_to_take_down_size,
 
2174
                               interface);
 
2175
        }
 
2176
      }
 
2177
    }
 
2178
    free(interfaces);
 
2179
    interfaces = NULL;
 
2180
    interfaces_size = 0;
 
2181
    if(debug and (interfaces_to_take_down == NULL)){
 
2182
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2183
    }
 
2184
  }
 
2185
  
 
2186
  if(quit_now){
 
2187
    goto end;
 
2188
  }
 
2189
  
 
2190
  ret = init_gnutls_global(pubkey, seckey);
 
2191
  if(ret == -1){
 
2192
    fprintf_plus(stderr, "init_gnutls_global failed\n");
 
2193
    exitcode = EX_UNAVAILABLE;
 
2194
    goto end;
 
2195
  } else {
 
2196
    gnutls_initialized = true;
 
2197
  }
 
2198
  
 
2199
  if(quit_now){
 
2200
    goto end;
 
2201
  }
 
2202
  
 
2203
  if(mkdtemp(tempdir) == NULL){
 
2204
    perror_plus("mkdtemp");
 
2205
    goto end;
 
2206
  }
 
2207
  tempdir_created = true;
 
2208
  
 
2209
  if(quit_now){
 
2210
    goto end;
 
2211
  }
 
2212
  
 
2213
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
2214
    fprintf_plus(stderr, "init_gpgme failed\n");
 
2215
    exitcode = EX_UNAVAILABLE;
 
2216
    goto end;
 
2217
  } else {
 
2218
    gpgme_initialized = true;
 
2219
  }
 
2220
  
 
2221
  if(quit_now){
 
2222
    goto end;
 
2223
  }
 
2224
  
 
2225
  if(connect_to != NULL){
 
2226
    /* Connect directly, do not use Zeroconf */
 
2227
    /* (Mainly meant for debugging) */
 
2228
    char *address = strrchr(connect_to, ':');
 
2229
    
 
2230
    if(address == NULL){
 
2231
      fprintf_plus(stderr, "No colon in address\n");
 
2232
      exitcode = EX_USAGE;
 
2233
      goto end;
 
2234
    }
 
2235
    
 
2236
    if(quit_now){
 
2237
      goto end;
 
2238
    }
 
2239
    
 
2240
    in_port_t port;
 
2241
    errno = 0;
 
2242
    tmpmax = strtoimax(address+1, &tmp, 10);
 
2243
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
 
2244
       or tmpmax != (in_port_t)tmpmax){
 
2245
      fprintf_plus(stderr, "Bad port number\n");
 
2246
      exitcode = EX_USAGE;
 
2247
      goto end;
 
2248
    }
 
2249
  
 
2250
    if(quit_now){
 
2251
      goto end;
 
2252
    }
 
2253
    
 
2254
    port = (in_port_t)tmpmax;
 
2255
    *address = '\0';
 
2256
    /* Colon in address indicates IPv6 */
 
2257
    int af;
 
2258
    if(strchr(connect_to, ':') != NULL){
 
2259
      af = AF_INET6;
 
2260
      /* Accept [] around IPv6 address - see RFC 5952 */
 
2261
      if(connect_to[0] == '[' and address[-1] == ']')
 
2262
        {
 
2263
          connect_to++;
 
2264
          address[-1] = '\0';
 
2265
        }
 
2266
    } else {
 
2267
      af = AF_INET;
 
2268
    }
 
2269
    address = connect_to;
 
2270
    
 
2271
    if(quit_now){
 
2272
      goto end;
 
2273
    }
 
2274
    
 
2275
    while(not quit_now){
 
2276
      ret = start_mandos_communication(address, port, if_index, af);
 
2277
      if(quit_now or ret == 0){
 
2278
        break;
 
2279
      }
 
2280
      if(debug){
 
2281
        fprintf_plus(stderr, "Retrying in %d seconds\n",
 
2282
                     (int)retry_interval);
 
2283
      }
 
2284
      sleep((int)retry_interval);
 
2285
    }
 
2286
    
 
2287
    if (not quit_now){
 
2288
      exitcode = EXIT_SUCCESS;
 
2289
    }
 
2290
    
 
2291
    goto end;
 
2292
  }
 
2293
  
 
2294
  if(quit_now){
 
2295
    goto end;
 
2296
  }
 
2297
  
 
2298
  {
688
2299
    AvahiServerConfig config;
689
 
    AvahiSServiceBrowser *sb = NULL;
690
 
    int error;
691
 
    int ret;
692
 
    int returncode = EXIT_SUCCESS;
693
 
    const char *interface = "eth0";
694
 
    struct ifreq network;
695
 
    int sd;
696
 
    char *connect_to = NULL;
697
 
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
698
 
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
699
 
                          .dh_bits = 2048, .priority = "SECURE256"};
700
 
    
701
 
    while (true){
702
 
      static struct option long_options[] = {
703
 
        {"debug", no_argument, (int *)&debug, 1},
704
 
        {"connect", required_argument, 0, 'C'},
705
 
        {"interface", required_argument, 0, 'i'},
706
 
        {"certdir", required_argument, 0, 'd'},
707
 
        {"certkey", required_argument, 0, 'c'},
708
 
        {"certfile", required_argument, 0, 'k'},
709
 
        {"dh_bits", required_argument, 0, 'D'},
710
 
        {"priority", required_argument, 0, 'p'},
711
 
        {0, 0, 0, 0} };
712
 
      
713
 
      int option_index = 0;
714
 
      ret = getopt_long (argc, argv, "i:", long_options,
715
 
                         &option_index);
716
 
      
717
 
      if (ret == -1){
718
 
        break;
719
 
      }
720
 
      
721
 
      switch(ret){
722
 
      case 0:
723
 
        break;
724
 
      case 'i':
725
 
        interface = optarg;
726
 
        break;
727
 
      case 'C':
728
 
        connect_to = optarg;
729
 
        break;
730
 
      case 'd':
731
 
        certdir = optarg;
732
 
        break;
733
 
      case 'c':
734
 
        certfile = optarg;
735
 
        break;
736
 
      case 'k':
737
 
        certkey = optarg;
738
 
        break;
739
 
      case 'D':
740
 
        {
741
 
          long int tmp;
742
 
          errno = 0;
743
 
          tmp = strtol(optarg, NULL, 10);
744
 
          if (errno == ERANGE){
745
 
            perror("strtol");
746
 
            exit(EXIT_FAILURE);
747
 
          }
748
 
          mc.dh_bits = tmp;
749
 
        }
750
 
        break;
751
 
      case 'p':
752
 
        mc.priority = optarg;
753
 
        break;
754
 
      default:
755
 
        exit(EXIT_FAILURE);
756
 
      }
757
 
    }
758
 
    
759
 
    certfile = combinepath(certdir, certfile);
760
 
    if (certfile == NULL){
761
 
      perror("combinepath");
762
 
      returncode = EXIT_FAILURE;
763
 
      goto exit;
764
 
    }
765
 
 
766
 
    certkey = combinepath(certdir, certkey);
767
 
    if (certkey == NULL){
768
 
      perror("combinepath");
769
 
      returncode = EXIT_FAILURE;
770
 
      goto exit;
771
 
    }
772
 
    
773
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
774
 
    if(if_index == 0){
775
 
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
776
 
      exit(EXIT_FAILURE);
777
 
    }
778
 
    
779
 
    if(connect_to != NULL){
780
 
      /* Connect directly, do not use Zeroconf */
781
 
      /* (Mainly meant for debugging) */
782
 
      char *address = strrchr(connect_to, ':');
783
 
      if(address == NULL){
784
 
        fprintf(stderr, "No colon in address\n");
785
 
        exit(EXIT_FAILURE);
786
 
      }
787
 
      errno = 0;
788
 
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
789
 
      if(errno){
790
 
        perror("Bad port number");
791
 
        exit(EXIT_FAILURE);
792
 
      }
793
 
      *address = '\0';
794
 
      address = connect_to;
795
 
      ret = start_mandos_communication(address, port, if_index);
796
 
      if(ret < 0){
797
 
        exit(EXIT_FAILURE);
798
 
      } else {
799
 
        exit(EXIT_SUCCESS);
800
 
      }
801
 
    }
802
 
    
803
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
804
 
    if(sd < 0) {
805
 
      perror("socket");
806
 
      returncode = EXIT_FAILURE;
807
 
      goto exit;
808
 
    }
809
 
    strcpy(network.ifr_name, interface);    
810
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
811
 
    if(ret == -1){
812
 
      
813
 
      perror("ioctl SIOCGIFFLAGS");
814
 
      returncode = EXIT_FAILURE;
815
 
      goto exit;
816
 
    }
817
 
    if((network.ifr_flags & IFF_UP) == 0){
818
 
      network.ifr_flags |= IFF_UP;
819
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
820
 
      if(ret == -1){
821
 
        perror("ioctl SIOCSIFFLAGS");
822
 
        returncode = EXIT_FAILURE;
823
 
        goto exit;
824
 
      }
825
 
    }
826
 
    close(sd);
827
 
    
828
 
    if (not debug){
829
 
      avahi_set_log_function(empty_log);
830
 
    }
831
 
    
832
 
    /* Initialize the psuedo-RNG */
833
 
    srand((unsigned int) time(NULL));
834
 
 
835
 
    /* Allocate main loop object */
836
 
    if (!(mc.simple_poll = avahi_simple_poll_new())) {
837
 
        fprintf(stderr, "Failed to create simple poll object.\n");
838
 
        returncode = EXIT_FAILURE;      
839
 
        goto exit;
840
 
    }
841
 
 
842
 
    /* Do not publish any local records */
 
2300
    /* Do not publish any local Zeroconf records */
843
2301
    avahi_server_config_init(&config);
844
2302
    config.publish_hinfo = 0;
845
2303
    config.publish_addresses = 0;
846
2304
    config.publish_workstation = 0;
847
2305
    config.publish_domain = 0;
848
 
 
 
2306
    
849
2307
    /* Allocate a new server */
850
 
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
851
 
                              &config, NULL, NULL, &error);
852
 
 
853
 
    /* Free the configuration data */
 
2308
    mc.server = avahi_server_new(avahi_simple_poll_get
 
2309
                                 (mc.simple_poll), &config, NULL,
 
2310
                                 NULL, &ret_errno);
 
2311
    
 
2312
    /* Free the Avahi configuration data */
854
2313
    avahi_server_config_free(&config);
855
 
 
856
 
    /* Check if creating the server object succeeded */
857
 
    if (!mc.server) {
858
 
        fprintf(stderr, "Failed to create server: %s\n",
859
 
                avahi_strerror(error));
860
 
        returncode = EXIT_FAILURE;
861
 
        goto exit;
862
 
    }
863
 
    
864
 
    /* Create the service browser */
865
 
    sb = avahi_s_service_browser_new(mc.server, if_index,
866
 
                                     AVAHI_PROTO_INET6,
867
 
                                     "_mandos._tcp", NULL, 0,
868
 
                                     browse_callback, &mc);
869
 
    if (!sb) {
870
 
        fprintf(stderr, "Failed to create service browser: %s\n",
871
 
                avahi_strerror(avahi_server_errno(mc.server)));
872
 
        returncode = EXIT_FAILURE;
873
 
        goto exit;
874
 
    }
875
 
    
876
 
    /* Run the main loop */
877
 
 
878
 
    if (debug){
879
 
      fprintf(stderr, "Starting avahi loop search\n");
880
 
    }
881
 
    
882
 
    avahi_simple_poll_loop(simple_poll);
883
 
    
884
 
 exit:
885
 
 
886
 
    if (debug){
887
 
      fprintf(stderr, "%s exiting\n", argv[0]);
888
 
    }
889
 
    
890
 
    /* Cleanup things */
891
 
    if (sb)
892
 
        avahi_s_service_browser_free(sb);
893
 
    
894
 
    if (mc.server)
895
 
        avahi_server_free(mc.server);
896
 
 
897
 
    if (simple_poll)
898
 
        avahi_simple_poll_free(simple_poll);
899
 
    free(certfile);
900
 
    free(certkey);
901
 
    
902
 
    return returncode;
 
2314
  }
 
2315
  
 
2316
  /* Check if creating the Avahi server object succeeded */
 
2317
  if(mc.server == NULL){
 
2318
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
 
2319
                 avahi_strerror(ret_errno));
 
2320
    exitcode = EX_UNAVAILABLE;
 
2321
    goto end;
 
2322
  }
 
2323
  
 
2324
  if(quit_now){
 
2325
    goto end;
 
2326
  }
 
2327
  
 
2328
  /* Create the Avahi service browser */
 
2329
  sb = avahi_s_service_browser_new(mc.server, if_index,
 
2330
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
 
2331
                                   NULL, 0, browse_callback, NULL);
 
2332
  if(sb == NULL){
 
2333
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
 
2334
                 avahi_strerror(avahi_server_errno(mc.server)));
 
2335
    exitcode = EX_UNAVAILABLE;
 
2336
    goto end;
 
2337
  }
 
2338
  
 
2339
  if(quit_now){
 
2340
    goto end;
 
2341
  }
 
2342
  
 
2343
  /* Run the main loop */
 
2344
  
 
2345
  if(debug){
 
2346
    fprintf_plus(stderr, "Starting Avahi loop search\n");
 
2347
  }
 
2348
 
 
2349
  ret = avahi_loop_with_timeout(mc.simple_poll,
 
2350
                                (int)(retry_interval * 1000));
 
2351
  if(debug){
 
2352
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
 
2353
                 (ret == 0) ? "successfully" : "with error");
 
2354
  }
 
2355
  
 
2356
 end:
 
2357
  
 
2358
  if(debug){
 
2359
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
2360
  }
 
2361
  
 
2362
  /* Cleanup things */
 
2363
  if(sb != NULL)
 
2364
    avahi_s_service_browser_free(sb);
 
2365
  
 
2366
  if(mc.server != NULL)
 
2367
    avahi_server_free(mc.server);
 
2368
  
 
2369
  if(mc.simple_poll != NULL)
 
2370
    avahi_simple_poll_free(mc.simple_poll);
 
2371
  
 
2372
  if(gnutls_initialized){
 
2373
    gnutls_certificate_free_credentials(mc.cred);
 
2374
    gnutls_global_deinit();
 
2375
    gnutls_dh_params_deinit(mc.dh_params);
 
2376
  }
 
2377
  
 
2378
  if(gpgme_initialized){
 
2379
    gpgme_release(mc.ctx);
 
2380
  }
 
2381
  
 
2382
  /* Cleans up the circular linked list of Mandos servers the client
 
2383
     has seen */
 
2384
  if(mc.current_server != NULL){
 
2385
    mc.current_server->prev->next = NULL;
 
2386
    while(mc.current_server != NULL){
 
2387
      server *next = mc.current_server->next;
 
2388
      free(mc.current_server);
 
2389
      mc.current_server = next;
 
2390
    }
 
2391
  }
 
2392
  
 
2393
  /* Re-raise priviliges */
 
2394
  {
 
2395
    raise_privileges();
 
2396
    
 
2397
    /* Run network hooks */
 
2398
    run_network_hooks("stop", interfaces_hooks != NULL ?
 
2399
                      interfaces_hooks : "", delay);
 
2400
    
 
2401
    /* Take down the network interfaces which were brought up */
 
2402
    {
 
2403
      char *interface = NULL;
 
2404
      while((interface=argz_next(interfaces_to_take_down,
 
2405
                                 interfaces_to_take_down_size,
 
2406
                                 interface))){
 
2407
        ret_errno = take_down_interface(interface);
 
2408
        if(ret_errno != 0){
 
2409
          errno = ret_errno;
 
2410
          perror_plus("Failed to take down interface");
 
2411
        }
 
2412
      }
 
2413
      if(debug and (interfaces_to_take_down == NULL)){
 
2414
        fprintf_plus(stderr, "No interfaces needed to be taken"
 
2415
                     " down\n");
 
2416
      }
 
2417
    }
 
2418
    
 
2419
    lower_privileges_permanently();
 
2420
  }
 
2421
  
 
2422
  free(interfaces_to_take_down);
 
2423
  free(interfaces_hooks);
 
2424
  
 
2425
  /* Removes the GPGME temp directory and all files inside */
 
2426
  if(tempdir_created){
 
2427
    struct dirent **direntries = NULL;
 
2428
    struct dirent *direntry = NULL;
 
2429
    int numentries = scandir(tempdir, &direntries, notdotentries,
 
2430
                             alphasort);
 
2431
    if (numentries > 0){
 
2432
      for(int i = 0; i < numentries; i++){
 
2433
        direntry = direntries[i];
 
2434
        char *fullname = NULL;
 
2435
        ret = asprintf(&fullname, "%s/%s", tempdir,
 
2436
                       direntry->d_name);
 
2437
        if(ret < 0){
 
2438
          perror_plus("asprintf");
 
2439
          continue;
 
2440
        }
 
2441
        ret = remove(fullname);
 
2442
        if(ret == -1){
 
2443
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
 
2444
                       strerror(errno));
 
2445
        }
 
2446
        free(fullname);
 
2447
      }
 
2448
    }
 
2449
 
 
2450
    /* need to clean even if 0 because man page doesn't specify */
 
2451
    free(direntries);
 
2452
    if (numentries == -1){
 
2453
      perror_plus("scandir");
 
2454
    }
 
2455
    ret = rmdir(tempdir);
 
2456
    if(ret == -1 and errno != ENOENT){
 
2457
      perror_plus("rmdir");
 
2458
    }
 
2459
  }
 
2460
  
 
2461
  if(quit_now){
 
2462
    sigemptyset(&old_sigterm_action.sa_mask);
 
2463
    old_sigterm_action.sa_handler = SIG_DFL;
 
2464
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
 
2465
                                            &old_sigterm_action,
 
2466
                                            NULL));
 
2467
    if(ret == -1){
 
2468
      perror_plus("sigaction");
 
2469
    }
 
2470
    do {
 
2471
      ret = raise(signal_received);
 
2472
    } while(ret != 0 and errno == EINTR);
 
2473
    if(ret != 0){
 
2474
      perror_plus("raise");
 
2475
      abort();
 
2476
    }
 
2477
    TEMP_FAILURE_RETRY(pause());
 
2478
  }
 
2479
  
 
2480
  return exitcode;
903
2481
}