/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/password-request.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-29 05:53:59 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080829055359-wkdasnyxtylmnxus
* mandos.xml (EXAMPLE): Replaced all occurences of command name with
                        "&COMMANDNAME;".

* plugins.d/password-prompt.c (main): Improved some documentation
                                      strings.  Do perror() of
                                      tcgetattr() fails.  Add debug
                                      output if interrupted by signal.
                                      Loop over write() instead of
                                      using fwrite() when outputting
                                      password.  Add debug output if
                                      getline() returns 0, unless it
                                      was caused by a signal.  Add
                                      exit status code to debug
                                      output.

* plugins.d/password-prompt.xml: Changed all single quotes to double
                                 quotes for consistency.  Removed
                                 <?xml-stylesheet>.
  (ENTITY TIMESTAMP): New.  Automatically updated by Emacs time-stamp
                      by using Emacs local variables.
  (/refentry/refentryinfo/title): Changed to "Mandos Manual".
  (/refentry/refentryinfo/productname): Changed to "Mandos".
  (/refentry/refentryinfo/date): New; set to "&TIMESTAMP;".
  (/refentry/refentryinfo/copyright): Split copyright holders.
  (/refentry/refnamediv/refpurpose): Improved wording.
  (SYNOPSIS): Fix to use correct markup.  Add short options.
  (DESCRIPTION, OPTIONS): Improved wording.
  (OPTIONS): Improved wording.  Use more correct markup.  Document
             short options.
  (EXIT STATUS): Add text.
  (ENVIRONMENT): Document use of "cryptsource" and "crypttarget".
  (FILES): REMOVED.
  (BUGS): Add text.
  (EXAMPLE): Added some examples.
  (SECURITY): Added text.
  (SEE ALSO): Remove reference to mandos(8).  Add reference to
              crypttab(5).

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