/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/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 01:09:36 UTC
  • mfrom: (24.1.9 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20080803010936-ujme8tgxceszfbi1
* plugbasedclient.c (main): New "--userid" and "--groupid" options.
                            Take an additional non-option argument and
                            parse it as a plus-separated and -prefixed
                            list of additional options.

* plugins.d/mandosclient.c (DH_BITS): Replaced with
                                      "mandos_context.dh_bits".  All
                                      users changed.
  (certdir): Renamed to "keydir".  All users changed.
  (certfile): Renamed to "pubkeyfile".  All users changed.
  (certkey): Renamed to "seckeyfile".  All users changed.
  (encrypted_session): Replaced with "mandos_context".  All users
                       changed.
  (initgnutls): Take additional "session" and "dh_params" arguments.
                All callers changed.
  (start_mandos_communication): Take additional "mc" argument.  All
                                callers changed.  Print target IPv6
                                address if different than supplied
                                string.
  (simple_poll) Replaced with "mandos_context.simple_poll".  All users
                changed.
  (server): Replaced with "mandos_context.server".  All users changed.
  (main): Default interface to "eth0".  Rename "--certdir" to
          "--keydir", "--certkey" to "--seckey", and "--certfile" to
          "--pubkey".  New options "--dh-bits" and "--priority".  If
          the interface is not up, bring it up.

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,2009 Teddy Hogeborn
13
 
 * Copyright © 2008,2009 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
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
 
 
40
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
 
 
42
 
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
45
 
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
 
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
 
                                   strtof(), abort() */
48
 
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
51
 
#include <sys/ioctl.h>          /* ioctl */
52
 
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
 
                                   sockaddr_in6, PF_INET6,
54
 
                                   SOCK_STREAM, uid_t, gid_t, open(),
55
 
                                   opendir(), DIR */
56
 
#include <sys/stat.h>           /* open() */
57
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
60
 
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
 
                                 */
62
 
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
63
 
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
 
#include <errno.h>              /* perror(), errno */
66
 
#include <time.h>               /* nanosleep(), time() */
67
 
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
68
 
                                   SIOCSIFFLAGS, if_indextoname(),
69
 
                                   if_nametoindex(), IF_NAMESIZE */
70
 
#include <netinet/in.h>         /* IN6_IS_ADDR_LINKLOCAL,
71
 
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
72
 
                                */
73
 
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
74
 
                                   getuid(), getgid(), seteuid(),
75
 
                                   setgid(), pause() */
76
 
#include <arpa/inet.h>          /* inet_pton(), htons */
77
 
#include <iso646.h>             /* not, or, and */
78
 
#include <argp.h>               /* struct argp_option, error_t, struct
79
 
                                   argp_state, struct argp,
80
 
                                   argp_parse(), ARGP_KEY_ARG,
81
 
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
82
 
#include <signal.h>             /* sigemptyset(), sigaddset(),
83
 
                                   sigaction(), SIGTERM, sig_atomic_t,
84
 
                                   raise() */
85
 
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
86
 
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
87
 
 
88
 
#ifdef __linux__
89
 
#include <sys/klog.h>           /* klogctl() */
90
 
#endif  /* __linux__ */
91
 
 
92
 
/* Avahi */
93
 
/* All Avahi types, constants and functions
94
 
 Avahi*, avahi_*,
95
 
 AVAHI_* */
 
34
 
 
35
#include <stdio.h>
 
36
#include <assert.h>
 
37
#include <stdlib.h>
 
38
#include <time.h>
 
39
#include <net/if.h>             /* if_nametoindex */
 
40
#include <sys/ioctl.h>          // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
 
41
#include <net/if.h>             // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
 
42
 
96
43
#include <avahi-core/core.h>
97
44
#include <avahi-core/lookup.h>
98
45
#include <avahi-core/log.h>
100
47
#include <avahi-common/malloc.h>
101
48
#include <avahi-common/error.h>
102
49
 
103
 
/* GnuTLS */
104
 
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
105
 
                                   functions:
106
 
                                   gnutls_*
107
 
                                   init_gnutls_session(),
108
 
                                   GNUTLS_* */
109
 
#include <gnutls/openpgp.h>
110
 
                          /* gnutls_certificate_set_openpgp_key_file(),
111
 
                                   GNUTLS_OPENPGP_FMT_BASE64 */
112
 
 
113
 
/* GPGME */
114
 
#include <gpgme.h>              /* All GPGME types, constants and
115
 
                                   functions:
116
 
                                   gpgme_*
117
 
                                   GPGME_PROTOCOL_OpenPGP,
118
 
                                   GPG_ERR_NO_* */
 
50
//mandos client part
 
51
#include <sys/types.h>          /* socket(), inet_pton() */
 
52
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
53
                                   struct in6_addr, inet_pton() */
 
54
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
 
55
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
 
56
 
 
57
#include <unistd.h>             /* close() */
 
58
#include <netinet/in.h>
 
59
#include <stdbool.h>            /* true */
 
60
#include <string.h>             /* memset */
 
61
#include <arpa/inet.h>          /* inet_pton() */
 
62
#include <iso646.h>             /* not */
 
63
 
 
64
// gpgme
 
65
#include <errno.h>              /* perror() */
 
66
#include <gpgme.h>
 
67
 
 
68
// getopt_long
 
69
#include <getopt.h>
119
70
 
120
71
#define BUFFER_SIZE 256
121
72
 
122
 
#define PATHDIR "/conf/conf.d/mandos"
123
 
#define SECKEY "seckey.txt"
124
 
#define PUBKEY "pubkey.txt"
 
73
static const char *keydir = "/conf/conf.d/mandos";
 
74
static const char *pubkeyfile = "pubkey.txt";
 
75
static const char *seckeyfile = "seckey.txt";
125
76
 
126
77
bool debug = false;
127
 
static const char mandos_protocol_version[] = "1";
128
 
const char *argp_program_version = "mandos-client " VERSION;
129
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
130
 
static const char sys_class_net[] = "/sys/class/net";
131
 
char *connect_to = NULL;
132
78
 
133
 
/* Used for passing in values through the Avahi callback functions */
 
79
/* Used for passing in values through all the callback functions */
134
80
typedef struct {
135
81
  AvahiSimplePoll *simple_poll;
136
82
  AvahiServer *server;
137
83
  gnutls_certificate_credentials_t cred;
138
84
  unsigned int dh_bits;
139
 
  gnutls_dh_params_t dh_params;
140
85
  const char *priority;
 
86
} mandos_context;
 
87
 
 
88
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
 
89
                                   char **new_packet,
 
90
                                   const char *homedir){
 
91
  gpgme_data_t dh_crypto, dh_plain;
141
92
  gpgme_ctx_t ctx;
142
 
} mandos_context;
143
 
 
144
 
/* global context so signal handler can reach it*/
145
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
146
 
                      .dh_bits = 1024, .priority = "SECURE256"
147
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP" };
148
 
 
149
 
sig_atomic_t quit_now = 0;
150
 
int signal_received = 0;
151
 
 
152
 
/*
153
 
 * Make additional room in "buffer" for at least BUFFER_SIZE more
154
 
 * bytes. "buffer_capacity" is how much is currently allocated,
155
 
 * "buffer_length" is how much is already used.
156
 
 */
157
 
size_t incbuffer(char **buffer, size_t buffer_length,
158
 
                  size_t buffer_capacity){
159
 
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
160
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
161
 
    if(buffer == NULL){
162
 
      return 0;
163
 
    }
164
 
    buffer_capacity += BUFFER_SIZE;
165
 
  }
166
 
  return buffer_capacity;
167
 
}
168
 
 
169
 
/* 
170
 
 * Initialize GPGME.
171
 
 */
172
 
static bool init_gpgme(const char *seckey,
173
 
                       const char *pubkey, const char *tempdir){
174
93
  gpgme_error_t rc;
 
94
  ssize_t ret;
 
95
  ssize_t new_packet_capacity = 0;
 
96
  ssize_t new_packet_length = 0;
175
97
  gpgme_engine_info_t engine_info;
176
 
  
177
 
  
178
 
  /*
179
 
   * Helper function to insert pub and seckey to the engine keyring.
180
 
   */
181
 
  bool import_key(const char *filename){
182
 
    int ret;
183
 
    int fd;
184
 
    gpgme_data_t pgp_data;
185
 
    
186
 
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
187
 
    if(fd == -1){
188
 
      perror("open");
189
 
      return false;
190
 
    }
191
 
    
192
 
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
193
 
    if(rc != GPG_ERR_NO_ERROR){
194
 
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
195
 
              gpgme_strsource(rc), gpgme_strerror(rc));
196
 
      return false;
197
 
    }
198
 
    
199
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
200
 
    if(rc != GPG_ERR_NO_ERROR){
201
 
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
202
 
              gpgme_strsource(rc), gpgme_strerror(rc));
203
 
      return false;
204
 
    }
205
 
    
206
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
207
 
    if(ret == -1){
208
 
      perror("close");
209
 
    }
210
 
    gpgme_data_release(pgp_data);
211
 
    return true;
212
 
  }
213
 
  
214
 
  if(debug){
215
 
    fprintf(stderr, "Initializing GPGME\n");
 
98
 
 
99
  if (debug){
 
100
    fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
216
101
  }
217
102
  
218
103
  /* Init GPGME */
219
104
  gpgme_check_version(NULL);
220
105
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
221
 
  if(rc != GPG_ERR_NO_ERROR){
 
106
  if (rc != GPG_ERR_NO_ERROR){
222
107
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
223
108
            gpgme_strsource(rc), gpgme_strerror(rc));
224
 
    return false;
 
109
    return -1;
225
110
  }
226
111
  
227
 
    /* Set GPGME home directory for the OpenPGP engine only */
228
 
  rc = gpgme_get_engine_info(&engine_info);
229
 
  if(rc != GPG_ERR_NO_ERROR){
 
112
  /* Set GPGME home directory */
 
113
  rc = gpgme_get_engine_info (&engine_info);
 
114
  if (rc != GPG_ERR_NO_ERROR){
230
115
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
231
116
            gpgme_strsource(rc), gpgme_strerror(rc));
232
 
    return false;
 
117
    return -1;
233
118
  }
234
119
  while(engine_info != NULL){
235
120
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
236
121
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
237
 
                            engine_info->file_name, tempdir);
 
122
                            engine_info->file_name, homedir);
238
123
      break;
239
124
    }
240
125
    engine_info = engine_info->next;
241
126
  }
242
127
  if(engine_info == NULL){
243
 
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
244
 
    return false;
245
 
  }
246
 
  
247
 
  /* Create new GPGME "context" */
248
 
  rc = gpgme_new(&(mc.ctx));
249
 
  if(rc != GPG_ERR_NO_ERROR){
250
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
251
 
            gpgme_strsource(rc), gpgme_strerror(rc));
252
 
    return false;
253
 
  }
254
 
  
255
 
  if(not import_key(pubkey) or not import_key(seckey)){
256
 
    return false;
257
 
  }
258
 
  
259
 
  return true;
260
 
}
261
 
 
262
 
/* 
263
 
 * Decrypt OpenPGP data.
264
 
 * Returns -1 on error
265
 
 */
266
 
static ssize_t pgp_packet_decrypt(const char *cryptotext,
267
 
                                  size_t crypto_size,
268
 
                                  char **plaintext){
269
 
  gpgme_data_t dh_crypto, dh_plain;
270
 
  gpgme_error_t rc;
271
 
  ssize_t ret;
272
 
  size_t plaintext_capacity = 0;
273
 
  ssize_t plaintext_length = 0;
274
 
  
275
 
  if(debug){
276
 
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
277
 
  }
278
 
  
279
 
  /* Create new GPGME data buffer from memory cryptotext */
280
 
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
281
 
                               0);
282
 
  if(rc != GPG_ERR_NO_ERROR){
 
128
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
 
129
    return -1;
 
130
  }
 
131
  
 
132
  /* Create new GPGME data buffer from packet buffer */
 
133
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
 
134
  if (rc != GPG_ERR_NO_ERROR){
283
135
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
284
136
            gpgme_strsource(rc), gpgme_strerror(rc));
285
137
    return -1;
287
139
  
288
140
  /* Create new empty GPGME data buffer for the plaintext */
289
141
  rc = gpgme_data_new(&dh_plain);
290
 
  if(rc != GPG_ERR_NO_ERROR){
 
142
  if (rc != GPG_ERR_NO_ERROR){
291
143
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
292
144
            gpgme_strsource(rc), gpgme_strerror(rc));
293
 
    gpgme_data_release(dh_crypto);
294
 
    return -1;
295
 
  }
296
 
  
297
 
  /* Decrypt data from the cryptotext data buffer to the plaintext
298
 
     data buffer */
299
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
300
 
  if(rc != GPG_ERR_NO_ERROR){
 
145
    return -1;
 
146
  }
 
147
  
 
148
  /* Create new GPGME "context" */
 
149
  rc = gpgme_new(&ctx);
 
150
  if (rc != GPG_ERR_NO_ERROR){
 
151
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
152
            gpgme_strsource(rc), gpgme_strerror(rc));
 
153
    return -1;
 
154
  }
 
155
  
 
156
  /* Decrypt data from the FILE pointer to the plaintext data
 
157
     buffer */
 
158
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
 
159
  if (rc != GPG_ERR_NO_ERROR){
301
160
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
302
161
            gpgme_strsource(rc), gpgme_strerror(rc));
303
 
    plaintext_length = -1;
304
 
    if(debug){
305
 
      gpgme_decrypt_result_t result;
306
 
      result = gpgme_op_decrypt_result(mc.ctx);
307
 
      if(result == NULL){
308
 
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
309
 
      } else {
310
 
        fprintf(stderr, "Unsupported algorithm: %s\n",
311
 
                result->unsupported_algorithm);
312
 
        fprintf(stderr, "Wrong key usage: %u\n",
313
 
                result->wrong_key_usage);
314
 
        if(result->file_name != NULL){
315
 
          fprintf(stderr, "File name: %s\n", result->file_name);
316
 
        }
317
 
        gpgme_recipient_t recipient;
318
 
        recipient = result->recipients;
 
162
    return -1;
 
163
  }
 
164
 
 
165
  if(debug){
 
166
    fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
 
167
  }
 
168
 
 
169
  if (debug){
 
170
    gpgme_decrypt_result_t result;
 
171
    result = gpgme_op_decrypt_result(ctx);
 
172
    if (result == NULL){
 
173
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
174
    } else {
 
175
      fprintf(stderr, "Unsupported algorithm: %s\n",
 
176
              result->unsupported_algorithm);
 
177
      fprintf(stderr, "Wrong key usage: %d\n",
 
178
              result->wrong_key_usage);
 
179
      if(result->file_name != NULL){
 
180
        fprintf(stderr, "File name: %s\n", result->file_name);
 
181
      }
 
182
      gpgme_recipient_t recipient;
 
183
      recipient = result->recipients;
 
184
      if(recipient){
319
185
        while(recipient != NULL){
320
186
          fprintf(stderr, "Public key algorithm: %s\n",
321
187
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
327
193
        }
328
194
      }
329
195
    }
330
 
    goto decrypt_end;
331
196
  }
332
197
  
333
 
  if(debug){
334
 
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
335
 
  }
 
198
  /* Delete the GPGME FILE pointer cryptotext data buffer */
 
199
  gpgme_data_release(dh_crypto);
336
200
  
337
201
  /* Seek back to the beginning of the GPGME plaintext data buffer */
338
 
  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
339
 
    perror("gpgme_data_seek");
340
 
    plaintext_length = -1;
341
 
    goto decrypt_end;
 
202
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
203
    perror("pgpme_data_seek");
342
204
  }
343
205
  
344
 
  *plaintext = NULL;
 
206
  *new_packet = 0;
345
207
  while(true){
346
 
    plaintext_capacity = incbuffer(plaintext,
347
 
                                      (size_t)plaintext_length,
348
 
                                      plaintext_capacity);
349
 
    if(plaintext_capacity == 0){
350
 
        perror("incbuffer");
351
 
        plaintext_length = -1;
352
 
        goto decrypt_end;
 
208
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
 
209
      *new_packet = realloc(*new_packet,
 
210
                            (unsigned int)new_packet_capacity
 
211
                            + BUFFER_SIZE);
 
212
      if (*new_packet == NULL){
 
213
        perror("realloc");
 
214
        return -1;
 
215
      }
 
216
      new_packet_capacity += BUFFER_SIZE;
353
217
    }
354
218
    
355
 
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
219
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
356
220
                          BUFFER_SIZE);
357
221
    /* Print the data, if any */
358
 
    if(ret == 0){
359
 
      /* EOF */
 
222
    if (ret == 0){
360
223
      break;
361
224
    }
362
225
    if(ret < 0){
363
226
      perror("gpgme_data_read");
364
 
      plaintext_length = -1;
365
 
      goto decrypt_end;
366
 
    }
367
 
    plaintext_length += ret;
368
 
  }
369
 
  
370
 
  if(debug){
371
 
    fprintf(stderr, "Decrypted password is: ");
372
 
    for(ssize_t i = 0; i < plaintext_length; i++){
373
 
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
374
 
    }
375
 
    fprintf(stderr, "\n");
376
 
  }
377
 
  
378
 
 decrypt_end:
379
 
  
380
 
  /* Delete the GPGME cryptotext data buffer */
381
 
  gpgme_data_release(dh_crypto);
 
227
      return -1;
 
228
    }
 
229
    new_packet_length += ret;
 
230
  }
 
231
 
 
232
  /* FIXME: check characters before printing to screen so to not print
 
233
     terminal control characters */
 
234
  /*   if(debug){ */
 
235
  /*     fprintf(stderr, "decrypted password is: "); */
 
236
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
 
237
  /*     fprintf(stderr, "\n"); */
 
238
  /*   } */
382
239
  
383
240
  /* Delete the GPGME plaintext data buffer */
384
241
  gpgme_data_release(dh_plain);
385
 
  return plaintext_length;
 
242
  return new_packet_length;
386
243
}
387
244
 
388
 
static const char * safer_gnutls_strerror(int value){
389
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
390
 
                                               -Wunreachable-code */
391
 
  if(ret == NULL)
 
245
static const char * safer_gnutls_strerror (int value) {
 
246
  const char *ret = gnutls_strerror (value);
 
247
  if (ret == NULL)
392
248
    ret = "(unknown)";
393
249
  return ret;
394
250
}
395
251
 
396
 
/* GnuTLS log function callback */
397
252
static void debuggnutls(__attribute__((unused)) int level,
398
253
                        const char* string){
399
 
  fprintf(stderr, "GnuTLS: %s", string);
 
254
  fprintf(stderr, "%s", string);
400
255
}
401
256
 
402
 
static int init_gnutls_global(const char *pubkeyfilename,
403
 
                              const char *seckeyfilename){
 
257
static int initgnutls(mandos_context *mc, gnutls_session_t *session,
 
258
                      gnutls_dh_params_t *dh_params){
 
259
  const char *err;
404
260
  int ret;
405
261
  
406
262
  if(debug){
407
263
    fprintf(stderr, "Initializing GnuTLS\n");
408
264
  }
409
 
  
410
 
  ret = gnutls_global_init();
411
 
  if(ret != GNUTLS_E_SUCCESS){
412
 
    fprintf(stderr, "GnuTLS global_init: %s\n",
413
 
            safer_gnutls_strerror(ret));
 
265
 
 
266
  if ((ret = gnutls_global_init ())
 
267
      != GNUTLS_E_SUCCESS) {
 
268
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
414
269
    return -1;
415
270
  }
416
271
  
417
 
  if(debug){
418
 
    /* "Use a log level over 10 to enable all debugging options."
419
 
     * - GnuTLS manual
420
 
     */
 
272
  if (debug){
421
273
    gnutls_global_set_log_level(11);
422
274
    gnutls_global_set_log_function(debuggnutls);
423
275
  }
424
276
  
425
 
  /* OpenPGP credentials */
426
 
  gnutls_certificate_allocate_credentials(&mc.cred);
427
 
  if(ret != GNUTLS_E_SUCCESS){
428
 
    fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
429
 
                                                    from
430
 
                                                    -Wunreachable-code
431
 
                                                 */
432
 
            safer_gnutls_strerror(ret));
433
 
    gnutls_global_deinit();
 
277
  /* openpgp credentials */
 
278
  if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
 
279
      != GNUTLS_E_SUCCESS) {
 
280
    fprintf (stderr, "memory error: %s\n",
 
281
             safer_gnutls_strerror(ret));
434
282
    return -1;
435
283
  }
436
284
  
437
285
  if(debug){
438
 
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
439
 
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
440
 
            seckeyfilename);
 
286
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
 
287
            " and keyfile %s as GnuTLS credentials\n", pubkeyfile,
 
288
            seckeyfile);
441
289
  }
442
290
  
443
291
  ret = gnutls_certificate_set_openpgp_key_file
444
 
    (mc.cred, pubkeyfilename, seckeyfilename,
445
 
     GNUTLS_OPENPGP_FMT_BASE64);
446
 
  if(ret != GNUTLS_E_SUCCESS){
447
 
    fprintf(stderr,
448
 
            "Error[%d] while reading the OpenPGP key pair ('%s',"
449
 
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
450
 
    fprintf(stderr, "The GnuTLS error is: %s\n",
451
 
            safer_gnutls_strerror(ret));
452
 
    goto globalfail;
453
 
  }
454
 
  
455
 
  /* GnuTLS server initialization */
456
 
  ret = gnutls_dh_params_init(&mc.dh_params);
457
 
  if(ret != GNUTLS_E_SUCCESS){
458
 
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
459
 
            " %s\n", safer_gnutls_strerror(ret));
460
 
    goto globalfail;
461
 
  }
462
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
463
 
  if(ret != GNUTLS_E_SUCCESS){
464
 
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
465
 
            safer_gnutls_strerror(ret));
466
 
    goto globalfail;
467
 
  }
468
 
  
469
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
470
 
  
471
 
  return 0;
472
 
  
473
 
 globalfail:
474
 
  
475
 
  gnutls_certificate_free_credentials(mc.cred);
476
 
  gnutls_global_deinit();
477
 
  gnutls_dh_params_deinit(mc.dh_params);
478
 
  return -1;
479
 
}
480
 
 
481
 
static int init_gnutls_session(gnutls_session_t *session){
482
 
  int ret;
483
 
  /* GnuTLS session creation */
484
 
  do {
485
 
    ret = gnutls_init(session, GNUTLS_SERVER);
486
 
    if(quit_now){
487
 
      return -1;
488
 
    }
489
 
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
490
 
  if(ret != GNUTLS_E_SUCCESS){
 
292
    (mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
 
293
  if (ret != GNUTLS_E_SUCCESS) {
 
294
    fprintf
 
295
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
 
296
       " '%s')\n",
 
297
       ret, pubkeyfile, seckeyfile);
 
298
    fprintf(stdout, "The Error is: %s\n",
 
299
            safer_gnutls_strerror(ret));
 
300
    return -1;
 
301
  }
 
302
  
 
303
  //GnuTLS server initialization
 
304
  if ((ret = gnutls_dh_params_init(dh_params))
 
305
      != GNUTLS_E_SUCCESS) {
 
306
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
 
307
             safer_gnutls_strerror(ret));
 
308
    return -1;
 
309
  }
 
310
  
 
311
  if ((ret = gnutls_dh_params_generate2(*dh_params, mc->dh_bits))
 
312
      != GNUTLS_E_SUCCESS) {
 
313
    fprintf (stderr, "Error in prime generation: %s\n",
 
314
             safer_gnutls_strerror(ret));
 
315
    return -1;
 
316
  }
 
317
  
 
318
  gnutls_certificate_set_dh_params(mc->cred, *dh_params);
 
319
  
 
320
  // GnuTLS session creation
 
321
  if ((ret = gnutls_init(session, GNUTLS_SERVER))
 
322
      != GNUTLS_E_SUCCESS){
491
323
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
492
324
            safer_gnutls_strerror(ret));
493
325
  }
494
326
  
495
 
  {
496
 
    const char *err;
497
 
    do {
498
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
499
 
      if(quit_now){
500
 
        gnutls_deinit(*session);
501
 
        return -1;
502
 
      }
503
 
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
504
 
    if(ret != GNUTLS_E_SUCCESS){
505
 
      fprintf(stderr, "Syntax error at: %s\n", err);
506
 
      fprintf(stderr, "GnuTLS error: %s\n",
507
 
              safer_gnutls_strerror(ret));
508
 
      gnutls_deinit(*session);
509
 
      return -1;
510
 
    }
 
327
  if ((ret = gnutls_priority_set_direct(*session, mc->priority, &err))
 
328
      != GNUTLS_E_SUCCESS) {
 
329
    fprintf(stderr, "Syntax error at: %s\n", err);
 
330
    fprintf(stderr, "GnuTLS error: %s\n",
 
331
            safer_gnutls_strerror(ret));
 
332
    return -1;
511
333
  }
512
334
  
513
 
  do {
514
 
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
515
 
                                 mc.cred);
516
 
    if(quit_now){
517
 
      gnutls_deinit(*session);
518
 
      return -1;
519
 
    }
520
 
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
521
 
  if(ret != GNUTLS_E_SUCCESS){
522
 
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
 
335
  if ((ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
336
                                    mc->cred))
 
337
      != GNUTLS_E_SUCCESS) {
 
338
    fprintf(stderr, "Error setting a credentials set: %s\n",
523
339
            safer_gnutls_strerror(ret));
524
 
    gnutls_deinit(*session);
525
340
    return -1;
526
341
  }
527
342
  
528
343
  /* ignore client certificate if any. */
529
 
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
 
344
  gnutls_certificate_server_set_request (*session,
 
345
                                         GNUTLS_CERT_IGNORE);
530
346
  
531
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
347
  gnutls_dh_set_prime_bits (*session, mc->dh_bits);
532
348
  
533
349
  return 0;
534
350
}
535
351
 
536
 
/* Avahi log function callback */
537
352
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
538
353
                      __attribute__((unused)) const char *txt){}
539
354
 
540
 
/* Called when a Mandos server is found */
541
355
static int start_mandos_communication(const char *ip, uint16_t port,
542
356
                                      AvahiIfIndex if_index,
543
 
                                      int af){
544
 
  int ret, tcp_sd = -1;
545
 
  ssize_t sret;
546
 
  union {
547
 
    struct sockaddr_in in;
548
 
    struct sockaddr_in6 in6;
549
 
  } to;
 
357
                                      mandos_context *mc){
 
358
  int ret, tcp_sd;
 
359
  struct sockaddr_in6 to;
550
360
  char *buffer = NULL;
551
 
  char *decrypted_buffer = NULL;
 
361
  char *decrypted_buffer;
552
362
  size_t buffer_length = 0;
553
363
  size_t buffer_capacity = 0;
554
 
  size_t written;
555
 
  int retval = -1;
 
364
  ssize_t decrypted_buffer_size;
 
365
  size_t written = 0;
 
366
  int retval = 0;
 
367
  char interface[IF_NAMESIZE];
556
368
  gnutls_session_t session;
557
 
  int pf;                       /* Protocol family */
558
 
  
559
 
  errno = 0;
560
 
  
561
 
  if(quit_now){
562
 
    errno = EINTR;
563
 
    return -1;
564
 
  }
565
 
  
566
 
  switch(af){
567
 
  case AF_INET6:
568
 
    pf = PF_INET6;
569
 
    break;
570
 
  case AF_INET:
571
 
    pf = PF_INET;
572
 
    break;
573
 
  default:
574
 
    fprintf(stderr, "Bad address family: %d\n", af);
575
 
    errno = EINVAL;
576
 
    return -1;
577
 
  }
578
 
  
579
 
  ret = init_gnutls_session(&session);
580
 
  if(ret != 0){
581
 
    return -1;
582
 
  }
 
369
  gnutls_dh_params_t dh_params;
583
370
  
584
371
  if(debug){
585
 
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
586
 
            "\n", ip, port);
 
372
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
 
373
            ip, port);
587
374
  }
588
375
  
589
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
590
 
  if(tcp_sd < 0){
591
 
    int e = errno;
 
376
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
 
377
  if(tcp_sd < 0) {
592
378
    perror("socket");
593
 
    errno = e;
594
 
    goto mandos_end;
595
 
  }
596
 
  
597
 
  if(quit_now){
598
 
    errno = EINTR;
599
 
    goto mandos_end;
600
 
  }
601
 
  
602
 
  memset(&to, 0, sizeof(to));
603
 
  if(af == AF_INET6){
604
 
    to.in6.sin6_family = (sa_family_t)af;
605
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
606
 
  } else {                      /* IPv4 */
607
 
    to.in.sin_family = (sa_family_t)af;
608
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
609
 
  }
610
 
  if(ret < 0 ){
611
 
    int e = errno;
 
379
    return -1;
 
380
  }
 
381
 
 
382
  if(debug){
 
383
    if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
384
      perror("if_indextoname");
 
385
      return -1;
 
386
    }
 
387
    fprintf(stderr, "Binding to interface %s\n", interface);
 
388
  }
 
389
  
 
390
  memset(&to,0,sizeof(to));     /* Spurious warning */
 
391
  to.sin6_family = AF_INET6;
 
392
  ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
 
393
  if (ret < 0 ){
612
394
    perror("inet_pton");
613
 
    errno = e;
614
 
    goto mandos_end;
 
395
    return -1;
615
396
  }
616
397
  if(ret == 0){
617
 
    int e = errno;
618
398
    fprintf(stderr, "Bad address: %s\n", ip);
619
 
    errno = e;
620
 
    goto mandos_end;
621
 
  }
622
 
  if(af == AF_INET6){
623
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
624
 
                                       -Wconversion and
625
 
                                       -Wunreachable-code */
626
 
    
627
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
628
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
629
 
                              -Wunreachable-code*/
630
 
      if(if_index == AVAHI_IF_UNSPEC){
631
 
        fprintf(stderr, "An IPv6 link-local address is incomplete"
632
 
                " without a network interface\n");
633
 
        errno = EINVAL;
634
 
        goto mandos_end;
635
 
      }
636
 
      /* Set the network interface number as scope */
637
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
638
 
    }
639
 
  } else {
640
 
    to.in.sin_port = htons(port); /* Spurious warnings from
641
 
                                     -Wconversion and
642
 
                                     -Wunreachable-code */
643
 
  }
 
399
    return -1;
 
400
  }
 
401
  to.sin6_port = htons(port);   /* Spurious warning */
644
402
  
645
 
  if(quit_now){
646
 
    errno = EINTR;
647
 
    goto mandos_end;
648
 
  }
 
403
  to.sin6_scope_id = (uint32_t)if_index;
649
404
  
650
405
  if(debug){
651
 
    if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
652
 
      char interface[IF_NAMESIZE];
653
 
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
654
 
        perror("if_indextoname");
655
 
      } else {
656
 
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
657
 
                ip, interface, port);
658
 
      }
659
 
    } else {
660
 
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
661
 
              port);
662
 
    }
663
 
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
664
 
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
665
 
    const char *pcret;
666
 
    if(af == AF_INET6){
667
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
668
 
                        sizeof(addrstr));
669
 
    } else {
670
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
671
 
                        sizeof(addrstr));
672
 
    }
673
 
    if(pcret == NULL){
 
406
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
 
407
    char addrstr[INET6_ADDRSTRLEN] = "";
 
408
    if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
 
409
                 sizeof(addrstr)) == NULL){
674
410
      perror("inet_ntop");
675
411
    } else {
676
412
      if(strcmp(addrstr, ip) != 0){
679
415
    }
680
416
  }
681
417
  
682
 
  if(quit_now){
683
 
    errno = EINTR;
684
 
    goto mandos_end;
685
 
  }
686
 
  
687
 
  if(af == AF_INET6){
688
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
689
 
  } else {
690
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
691
 
  }
692
 
  if(ret < 0){
693
 
    int e = errno;
 
418
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
 
419
  if (ret < 0){
694
420
    perror("connect");
695
 
    errno = e;
696
 
    goto mandos_end;
697
 
  }
698
 
  
699
 
  if(quit_now){
700
 
    errno = EINTR;
701
 
    goto mandos_end;
702
 
  }
703
 
  
704
 
  const char *out = mandos_protocol_version;
705
 
  written = 0;
706
 
  while(true){
707
 
    size_t out_size = strlen(out);
708
 
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
709
 
                                   out_size - written));
710
 
    if(ret == -1){
711
 
      int e = errno;
712
 
      perror("write");
713
 
      errno = e;
714
 
      goto mandos_end;
715
 
    }
716
 
    written += (size_t)ret;
717
 
    if(written < out_size){
718
 
      continue;
719
 
    } else {
720
 
      if(out == mandos_protocol_version){
721
 
        written = 0;
722
 
        out = "\r\n";
723
 
      } else {
724
 
        break;
725
 
      }
726
 
    }
727
 
  
728
 
    if(quit_now){
729
 
      errno = EINTR;
730
 
      goto mandos_end;
731
 
    }
732
 
  }
 
421
    return -1;
 
422
  }
 
423
  
 
424
  ret = initgnutls (mc, &session, &dh_params);
 
425
  if (ret != 0){
 
426
    retval = -1;
 
427
    return -1;
 
428
  }
 
429
  
 
430
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
733
431
  
734
432
  if(debug){
735
433
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
736
434
  }
737
435
  
738
 
  if(quit_now){
739
 
    errno = EINTR;
740
 
    goto mandos_end;
741
 
  }
742
 
  
743
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
744
 
  
745
 
  if(quit_now){
746
 
    errno = EINTR;
747
 
    goto mandos_end;
748
 
  }
749
 
  
750
 
  do {
751
 
    ret = gnutls_handshake(session);
752
 
    if(quit_now){
753
 
      errno = EINTR;
754
 
      goto mandos_end;
755
 
    }
756
 
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
757
 
  
758
 
  if(ret != GNUTLS_E_SUCCESS){
 
436
  ret = gnutls_handshake (session);
 
437
  
 
438
  if (ret != GNUTLS_E_SUCCESS){
759
439
    if(debug){
760
 
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
761
 
      gnutls_perror(ret);
 
440
      fprintf(stderr, "\n*** Handshake failed ***\n");
 
441
      gnutls_perror (ret);
762
442
    }
763
 
    errno = EPROTO;
764
 
    goto mandos_end;
 
443
    retval = -1;
 
444
    goto exit;
765
445
  }
766
446
  
767
 
  /* Read OpenPGP packet that contains the wanted password */
 
447
  //Retrieve OpenPGP packet that contains the wanted password
768
448
  
769
449
  if(debug){
770
 
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
 
450
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
771
451
            ip);
772
452
  }
773
 
  
 
453
 
774
454
  while(true){
775
 
    
776
 
    if(quit_now){
777
 
      errno = EINTR;
778
 
      goto mandos_end;
779
 
    }
780
 
    
781
 
    buffer_capacity = incbuffer(&buffer, buffer_length,
782
 
                                   buffer_capacity);
783
 
    if(buffer_capacity == 0){
784
 
      int e = errno;
785
 
      perror("incbuffer");
786
 
      errno = e;
787
 
      goto mandos_end;
788
 
    }
789
 
    
790
 
    if(quit_now){
791
 
      errno = EINTR;
792
 
      goto mandos_end;
793
 
    }
794
 
    
795
 
    sret = gnutls_record_recv(session, buffer+buffer_length,
796
 
                              BUFFER_SIZE);
797
 
    if(sret == 0){
 
455
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
 
456
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
 
457
      if (buffer == NULL){
 
458
        perror("realloc");
 
459
        goto exit;
 
460
      }
 
461
      buffer_capacity += BUFFER_SIZE;
 
462
    }
 
463
    
 
464
    ret = gnutls_record_recv(session, buffer+buffer_length,
 
465
                             BUFFER_SIZE);
 
466
    if (ret == 0){
798
467
      break;
799
468
    }
800
 
    if(sret < 0){
801
 
      switch(sret){
 
469
    if (ret < 0){
 
470
      switch(ret){
802
471
      case GNUTLS_E_INTERRUPTED:
803
472
      case GNUTLS_E_AGAIN:
804
473
        break;
805
474
      case GNUTLS_E_REHANDSHAKE:
806
 
        do {
807
 
          ret = gnutls_handshake(session);
808
 
          
809
 
          if(quit_now){
810
 
            errno = EINTR;
811
 
            goto mandos_end;
812
 
          }
813
 
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
814
 
        if(ret < 0){
815
 
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
816
 
          gnutls_perror(ret);
817
 
          errno = EPROTO;
818
 
          goto mandos_end;
 
475
        ret = gnutls_handshake (session);
 
476
        if (ret < 0){
 
477
          fprintf(stderr, "\n*** Handshake failed ***\n");
 
478
          gnutls_perror (ret);
 
479
          retval = -1;
 
480
          goto exit;
819
481
        }
820
482
        break;
821
483
      default:
822
484
        fprintf(stderr, "Unknown error while reading data from"
823
 
                " encrypted session with Mandos server\n");
824
 
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
825
 
        errno = EIO;
826
 
        goto mandos_end;
 
485
                " encrypted session with mandos server\n");
 
486
        retval = -1;
 
487
        gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
488
        goto exit;
827
489
      }
828
490
    } else {
829
 
      buffer_length += (size_t) sret;
830
 
    }
831
 
  }
832
 
  
833
 
  if(debug){
834
 
    fprintf(stderr, "Closing TLS session\n");
835
 
  }
836
 
  
837
 
  if(quit_now){
838
 
    errno = EINTR;
839
 
    goto mandos_end;
840
 
  }
841
 
  
842
 
  do {
843
 
    ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
844
 
    if(quit_now){
845
 
      errno = EINTR;
846
 
      goto mandos_end;
847
 
    }
848
 
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
849
 
  
850
 
  if(buffer_length > 0){
851
 
    ssize_t decrypted_buffer_size;
 
491
      buffer_length += (size_t) ret;
 
492
    }
 
493
  }
 
494
  
 
495
  if (buffer_length > 0){
852
496
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
853
497
                                               buffer_length,
854
 
                                               &decrypted_buffer);
855
 
    if(decrypted_buffer_size >= 0){
856
 
      
857
 
      written = 0;
 
498
                                               &decrypted_buffer,
 
499
                                               keydir);
 
500
    if (decrypted_buffer_size >= 0){
858
501
      while(written < (size_t) decrypted_buffer_size){
859
 
        if(quit_now){
860
 
          errno = EINTR;
861
 
          goto mandos_end;
862
 
        }
863
 
        
864
 
        ret = (int)fwrite(decrypted_buffer + written, 1,
865
 
                          (size_t)decrypted_buffer_size - written,
866
 
                          stdout);
 
502
        ret = (int)fwrite (decrypted_buffer + written, 1,
 
503
                           (size_t)decrypted_buffer_size - written,
 
504
                           stdout);
867
505
        if(ret == 0 and ferror(stdout)){
868
 
          int e = errno;
869
506
          if(debug){
870
507
            fprintf(stderr, "Error writing encrypted data: %s\n",
871
508
                    strerror(errno));
872
509
          }
873
 
          errno = e;
874
 
          goto mandos_end;
 
510
          retval = -1;
 
511
          break;
875
512
        }
876
513
        written += (size_t)ret;
877
514
      }
878
 
      retval = 0;
879
 
    }
880
 
  }
881
 
  
882
 
  /* Shutdown procedure */
883
 
  
884
 
 mandos_end:
885
 
  {
886
 
    int e = errno;
887
 
    free(decrypted_buffer);
888
 
    free(buffer);
889
 
    if(tcp_sd >= 0){
890
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
891
 
    }
892
 
    if(ret == -1){
893
 
      if(e == 0){
894
 
        e = errno;
895
 
      }
896
 
      perror("close");
897
 
    }
898
 
    gnutls_deinit(session);
899
 
    if(quit_now){
900
 
      e = EINTR;
 
515
      free(decrypted_buffer);
 
516
    } else {
901
517
      retval = -1;
902
518
    }
903
 
    errno = e;
904
 
  }
 
519
  }
 
520
 
 
521
  //shutdown procedure
 
522
 
 
523
  if(debug){
 
524
    fprintf(stderr, "Closing TLS session\n");
 
525
  }
 
526
 
 
527
  free(buffer);
 
528
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
529
 exit:
 
530
  close(tcp_sd);
 
531
  gnutls_deinit (session);
 
532
  gnutls_certificate_free_credentials (mc->cred);
 
533
  gnutls_global_deinit ();
905
534
  return retval;
906
535
}
907
536
 
908
 
static void resolve_callback(AvahiSServiceResolver *r,
909
 
                             AvahiIfIndex interface,
910
 
                             AvahiProtocol proto,
911
 
                             AvahiResolverEvent event,
912
 
                             const char *name,
913
 
                             const char *type,
914
 
                             const char *domain,
915
 
                             const char *host_name,
916
 
                             const AvahiAddress *address,
917
 
                             uint16_t port,
918
 
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
919
 
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
920
 
                             flags,
921
 
                             AVAHI_GCC_UNUSED void* userdata){
922
 
  assert(r);
 
537
static void resolve_callback( AvahiSServiceResolver *r,
 
538
                              AvahiIfIndex interface,
 
539
                              AVAHI_GCC_UNUSED AvahiProtocol protocol,
 
540
                              AvahiResolverEvent event,
 
541
                              const char *name,
 
542
                              const char *type,
 
543
                              const char *domain,
 
544
                              const char *host_name,
 
545
                              const AvahiAddress *address,
 
546
                              uint16_t port,
 
547
                              AVAHI_GCC_UNUSED AvahiStringList *txt,
 
548
                              AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
549
                              void* userdata) {
 
550
  mandos_context *mc = userdata;
 
551
  assert(r);                    /* Spurious warning */
923
552
  
924
553
  /* Called whenever a service has been resolved successfully or
925
554
     timed out */
926
555
  
927
 
  if(quit_now){
928
 
    return;
929
 
  }
930
 
  
931
 
  switch(event){
 
556
  switch (event) {
932
557
  default:
933
558
  case AVAHI_RESOLVER_FAILURE:
934
 
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
935
 
            " of type '%s' in domain '%s': %s\n", name, type, domain,
936
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
559
    fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
 
560
            " type '%s' in domain '%s': %s\n", name, type, domain,
 
561
            avahi_strerror(avahi_server_errno(mc->server)));
937
562
    break;
938
563
    
939
564
  case AVAHI_RESOLVER_FOUND:
941
566
      char ip[AVAHI_ADDRESS_STR_MAX];
942
567
      avahi_address_snprint(ip, sizeof(ip), address);
943
568
      if(debug){
944
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
945
 
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
946
 
                ip, (intmax_t)interface, port);
 
569
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
 
570
                " port %d\n", name, host_name, ip, port);
947
571
      }
948
 
      int ret = start_mandos_communication(ip, port, interface,
949
 
                                           avahi_proto_to_af(proto));
950
 
      if(ret == 0){
951
 
        avahi_simple_poll_quit(mc.simple_poll);
 
572
      int ret = start_mandos_communication(ip, port, interface, mc);
 
573
      if (ret == 0){
 
574
        exit(EXIT_SUCCESS);
952
575
      }
953
576
    }
954
577
  }
955
578
  avahi_s_service_resolver_free(r);
956
579
}
957
580
 
958
 
static void browse_callback(AvahiSServiceBrowser *b,
959
 
                            AvahiIfIndex interface,
960
 
                            AvahiProtocol protocol,
961
 
                            AvahiBrowserEvent event,
962
 
                            const char *name,
963
 
                            const char *type,
964
 
                            const char *domain,
965
 
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
966
 
                            flags,
967
 
                            AVAHI_GCC_UNUSED void* userdata){
968
 
  assert(b);
 
581
static void browse_callback( AvahiSServiceBrowser *b,
 
582
                             AvahiIfIndex interface,
 
583
                             AvahiProtocol protocol,
 
584
                             AvahiBrowserEvent event,
 
585
                             const char *name,
 
586
                             const char *type,
 
587
                             const char *domain,
 
588
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
589
                             void* userdata) {
 
590
  mandos_context *mc = userdata;
 
591
  assert(b);                    /* Spurious warning */
969
592
  
970
593
  /* Called whenever a new services becomes available on the LAN or
971
594
     is removed from the LAN */
972
595
  
973
 
  if(quit_now){
974
 
    return;
975
 
  }
976
 
  
977
 
  switch(event){
 
596
  switch (event) {
978
597
  default:
979
598
  case AVAHI_BROWSER_FAILURE:
980
599
    
981
 
    fprintf(stderr, "(Avahi browser) %s\n",
982
 
            avahi_strerror(avahi_server_errno(mc.server)));
983
 
    avahi_simple_poll_quit(mc.simple_poll);
 
600
    fprintf(stderr, "(Browser) %s\n",
 
601
            avahi_strerror(avahi_server_errno(mc->server)));
 
602
    avahi_simple_poll_quit(mc->simple_poll);
984
603
    return;
985
604
    
986
605
  case AVAHI_BROWSER_NEW:
987
 
    /* We ignore the returned Avahi resolver object. In the callback
988
 
       function we free it. If the Avahi server is terminated before
989
 
       the callback function is called the Avahi server will free the
990
 
       resolver for us. */
 
606
    /* We ignore the returned resolver object. In the callback
 
607
       function we free it. If the server is terminated before
 
608
       the callback function is called the server will free
 
609
       the resolver for us. */
991
610
    
992
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
993
 
                                    name, type, domain, protocol, 0,
994
 
                                    resolve_callback, NULL) == NULL)
995
 
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
996
 
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
611
    if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
 
612
                                       type, domain,
 
613
                                       AVAHI_PROTO_INET6, 0,
 
614
                                       resolve_callback, mc)))
 
615
      fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
 
616
              avahi_strerror(avahi_server_errno(mc->server)));
997
617
    break;
998
618
    
999
619
  case AVAHI_BROWSER_REMOVE:
1001
621
    
1002
622
  case AVAHI_BROWSER_ALL_FOR_NOW:
1003
623
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
1004
 
    if(debug){
1005
 
      fprintf(stderr, "No Mandos server found, still searching...\n");
1006
 
    }
1007
624
    break;
1008
625
  }
1009
626
}
1010
627
 
1011
 
/* stop main loop after sigterm has been called */
1012
 
static void handle_sigterm(int sig){
1013
 
  if(quit_now){
1014
 
    return;
1015
 
  }
1016
 
  quit_now = 1;
1017
 
  signal_received = sig;
1018
 
  int old_errno = errno;
1019
 
  if(mc.simple_poll != NULL){
1020
 
    avahi_simple_poll_quit(mc.simple_poll);
1021
 
  }
1022
 
  errno = old_errno;
1023
 
}
1024
 
 
1025
 
/* 
1026
 
 * This function determines if a directory entry in /sys/class/net
1027
 
 * corresponds to an acceptable network device.
1028
 
 * (This function is passed to scandir(3) as a filter function.)
1029
 
 */
1030
 
int good_interface(const struct dirent *if_entry){
1031
 
  ssize_t ssret;
1032
 
  char *flagname = NULL;
1033
 
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1034
 
                     if_entry->d_name);
1035
 
  if(ret < 0){
1036
 
    perror("asprintf");
1037
 
    return 0;
1038
 
  }
1039
 
  if(if_entry->d_name[0] == '.'){
1040
 
    return 0;
1041
 
  }
1042
 
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1043
 
  if(flags_fd == -1){
1044
 
    perror("open");
1045
 
    return 0;
1046
 
  }
1047
 
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
1048
 
  /* read line from flags_fd */
1049
 
  ssize_t to_read = (sizeof(ifreq_flags)*2)+3; /* "0x1003\n" */
1050
 
  char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1051
 
  flagstring[(size_t)to_read] = '\0';
1052
 
  if(flagstring == NULL){
1053
 
    perror("malloc");
1054
 
    close(flags_fd);
1055
 
    return 0;
1056
 
  }
1057
 
  while(to_read > 0){
1058
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1059
 
                                             (size_t)to_read));
1060
 
    if(ssret == -1){
1061
 
      perror("read");
1062
 
      free(flagstring);
1063
 
      close(flags_fd);
1064
 
      return 0;
1065
 
    }
1066
 
    to_read -= ssret;
1067
 
    if(ssret == 0){
1068
 
      break;
1069
 
    }
1070
 
  }
1071
 
  close(flags_fd);
1072
 
  intmax_t tmpmax;
1073
 
  char *tmp;
1074
 
  errno = 0;
1075
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1076
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1077
 
                                         and not (isspace(*tmp)))
1078
 
     or tmpmax != (ifreq_flags)tmpmax){
1079
 
    if(debug){
1080
 
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1081
 
              flagstring, if_entry->d_name);
1082
 
    }
1083
 
    free(flagstring);
1084
 
    return 0;
1085
 
  }
1086
 
  free(flagstring);
1087
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
1088
 
  /* Reject the loopback device */
1089
 
  if(flags & IFF_LOOPBACK){
1090
 
    if(debug){
1091
 
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1092
 
              if_entry->d_name);
1093
 
    }
1094
 
    return 0;
1095
 
  }
1096
 
  /* Accept point-to-point devices only if connect_to is specified */
1097
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1098
 
    if(debug){
1099
 
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1100
 
              if_entry->d_name);
1101
 
    }
1102
 
    return 1;
1103
 
  }
1104
 
  /* Otherwise, reject non-broadcast-capable devices */
1105
 
  if(not (flags & IFF_BROADCAST)){
1106
 
    if(debug){
1107
 
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1108
 
              if_entry->d_name);
1109
 
    }
1110
 
    return 0;
1111
 
  }
1112
 
  /* Accept this device */
1113
 
  if(debug){
1114
 
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
1115
 
            if_entry->d_name);
1116
 
  }
1117
 
  return 1;
1118
 
}
1119
 
 
1120
 
int main(int argc, char *argv[]){
1121
 
  AvahiSServiceBrowser *sb = NULL;
1122
 
  int error;
1123
 
  int ret;
1124
 
  intmax_t tmpmax;
1125
 
  char *tmp;
1126
 
  int exitcode = EXIT_SUCCESS;
1127
 
  const char *interface = "";
1128
 
  struct ifreq network;
1129
 
  int sd = -1;
1130
 
  bool take_down_interface = false;
1131
 
  uid_t uid;
1132
 
  gid_t gid;
1133
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1134
 
  bool tempdir_created = false;
1135
 
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1136
 
  const char *seckey = PATHDIR "/" SECKEY;
1137
 
  const char *pubkey = PATHDIR "/" PUBKEY;
1138
 
  
1139
 
  bool gnutls_initialized = false;
1140
 
  bool gpgme_initialized = false;
1141
 
  float delay = 2.5f;
1142
 
  
1143
 
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1144
 
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1145
 
  
1146
 
  uid = getuid();
1147
 
  gid = getgid();
1148
 
  
1149
 
  /* Lower any group privileges we might have, just to be safe */
1150
 
  errno = 0;
1151
 
  ret = setgid(gid);
1152
 
  if(ret == -1){
1153
 
    perror("setgid");
1154
 
  }
1155
 
  
1156
 
  /* Lower user privileges (temporarily) */
1157
 
  errno = 0;
1158
 
  ret = seteuid(uid);
1159
 
  if(ret == -1){
1160
 
    perror("seteuid");
1161
 
  }
1162
 
  
1163
 
  if(quit_now){
1164
 
    goto end;
1165
 
  }
1166
 
  
1167
 
  {
1168
 
    struct argp_option options[] = {
1169
 
      { .name = "debug", .key = 128,
1170
 
        .doc = "Debug mode", .group = 3 },
1171
 
      { .name = "connect", .key = 'c',
1172
 
        .arg = "ADDRESS:PORT",
1173
 
        .doc = "Connect directly to a specific Mandos server",
1174
 
        .group = 1 },
1175
 
      { .name = "interface", .key = 'i',
1176
 
        .arg = "NAME",
1177
 
        .doc = "Network interface that will be used to search for"
1178
 
        " Mandos servers",
1179
 
        .group = 1 },
1180
 
      { .name = "seckey", .key = 's',
1181
 
        .arg = "FILE",
1182
 
        .doc = "OpenPGP secret key file base name",
1183
 
        .group = 1 },
1184
 
      { .name = "pubkey", .key = 'p',
1185
 
        .arg = "FILE",
1186
 
        .doc = "OpenPGP public key file base name",
1187
 
        .group = 2 },
1188
 
      { .name = "dh-bits", .key = 129,
1189
 
        .arg = "BITS",
1190
 
        .doc = "Bit length of the prime number used in the"
1191
 
        " Diffie-Hellman key exchange",
1192
 
        .group = 2 },
1193
 
      { .name = "priority", .key = 130,
1194
 
        .arg = "STRING",
1195
 
        .doc = "GnuTLS priority string for the TLS handshake",
1196
 
        .group = 1 },
1197
 
      { .name = "delay", .key = 131,
1198
 
        .arg = "SECONDS",
1199
 
        .doc = "Maximum delay to wait for interface startup",
1200
 
        .group = 2 },
1201
 
      /*
1202
 
       * These reproduce what we would get without ARGP_NO_HELP
1203
 
       */
1204
 
      { .name = "help", .key = '?',
1205
 
        .doc = "Give this help list", .group = -1 },
1206
 
      { .name = "usage", .key = -3,
1207
 
        .doc = "Give a short usage message", .group = -1 },
1208
 
      { .name = "version", .key = 'V',
1209
 
        .doc = "Print program version", .group = -1 },
1210
 
      { .name = NULL }
1211
 
    };
 
628
/* Combines file name and path and returns the malloced new
 
629
   string. some sane checks could/should be added */
 
630
static const char *combinepath(const char *first, const char *second){
 
631
  size_t f_len = strlen(first);
 
632
  size_t s_len = strlen(second);
 
633
  char *tmp = malloc(f_len + s_len + 2);
 
634
  if (tmp == NULL){
 
635
    return NULL;
 
636
  }
 
637
  if(f_len > 0){
 
638
    memcpy(tmp, first, f_len);  /* Spurious warning */
 
639
  }
 
640
  tmp[f_len] = '/';
 
641
  if(s_len > 0){
 
642
    memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
 
643
  }
 
644
  tmp[f_len + 1 + s_len] = '\0';
 
645
  return tmp;
 
646
}
 
647
 
 
648
 
 
649
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
650
    AvahiServerConfig config;
 
651
    AvahiSServiceBrowser *sb = NULL;
 
652
    int error;
 
653
    int ret;
 
654
    int debug_int;
 
655
    int returncode = EXIT_SUCCESS;
 
656
    const char *interface = "eth0";
 
657
    struct ifreq network;
 
658
    int sd;
 
659
    char *connect_to = NULL;
 
660
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
661
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
662
                          .dh_bits = 1024, .priority = "SECURE256"};
1212
663
    
1213
 
    error_t parse_opt(int key, char *arg,
1214
 
                      struct argp_state *state){
1215
 
      errno = 0;
1216
 
      switch(key){
1217
 
      case 128:                 /* --debug */
1218
 
        debug = true;
1219
 
        break;
1220
 
      case 'c':                 /* --connect */
1221
 
        connect_to = arg;
1222
 
        break;
1223
 
      case 'i':                 /* --interface */
1224
 
        interface = arg;
1225
 
        break;
1226
 
      case 's':                 /* --seckey */
1227
 
        seckey = arg;
1228
 
        break;
1229
 
      case 'p':                 /* --pubkey */
1230
 
        pubkey = arg;
1231
 
        break;
1232
 
      case 129:                 /* --dh-bits */
1233
 
        errno = 0;
1234
 
        tmpmax = strtoimax(arg, &tmp, 10);
1235
 
        if(errno != 0 or tmp == arg or *tmp != '\0'
1236
 
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
1237
 
          argp_error(state, "Bad number of DH bits");
1238
 
        }
1239
 
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1240
 
        break;
1241
 
      case 130:                 /* --priority */
1242
 
        mc.priority = arg;
1243
 
        break;
1244
 
      case 131:                 /* --delay */
1245
 
        errno = 0;
1246
 
        delay = strtof(arg, &tmp);
1247
 
        if(errno != 0 or tmp == arg or *tmp != '\0'){
1248
 
          argp_error(state, "Bad delay");
1249
 
        }
1250
 
        break;
1251
 
        /*
1252
 
         * These reproduce what we would get without ARGP_NO_HELP
1253
 
         */
1254
 
      case '?':                 /* --help */
1255
 
        argp_state_help(state, state->out_stream,
1256
 
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1257
 
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
1258
 
      case -3:                  /* --usage */
1259
 
        argp_state_help(state, state->out_stream,
1260
 
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1261
 
      case 'V':                 /* --version */
1262
 
        fprintf(state->out_stream, "%s\n", argp_program_version);
1263
 
        exit(argp_err_exit_status);
1264
 
        break;
 
664
    debug_int = debug ? 1 : 0;
 
665
    while (true){
 
666
      struct option long_options[] = {
 
667
        {"debug", no_argument, &debug_int, 1},
 
668
        {"connect", required_argument, NULL, 'c'},
 
669
        {"interface", required_argument, NULL, 'i'},
 
670
        {"keydir", required_argument, NULL, 'd'},
 
671
        {"seckey", required_argument, NULL, 's'},
 
672
        {"pubkey", required_argument, NULL, 'p'},
 
673
        {"dh-bits", required_argument, NULL, 'D'},
 
674
        {"priority", required_argument, NULL, 'P'},
 
675
        {0, 0, 0, 0} };
 
676
      
 
677
      int option_index = 0;
 
678
      ret = getopt_long (argc, argv, "i:", long_options,
 
679
                         &option_index);
 
680
      
 
681
      if (ret == -1){
 
682
        break;
 
683
      }
 
684
      
 
685
      switch(ret){
 
686
      case 0:
 
687
        break;
 
688
      case 'i':
 
689
        interface = optarg;
 
690
        break;
 
691
      case 'c':
 
692
        connect_to = optarg;
 
693
        break;
 
694
      case 'd':
 
695
        keydir = optarg;
 
696
        break;
 
697
      case 'p':
 
698
        pubkeyfile = optarg;
 
699
        break;
 
700
      case 's':
 
701
        seckeyfile = optarg;
 
702
        break;
 
703
      case 'D':
 
704
        errno = 0;
 
705
        mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
 
706
        if (errno){
 
707
          perror("strtol");
 
708
          exit(EXIT_FAILURE);
 
709
        }
 
710
        break;
 
711
      case 'P':
 
712
        mc.priority = optarg;
 
713
        break;
 
714
      case '?':
1265
715
      default:
1266
 
        return ARGP_ERR_UNKNOWN;
1267
 
      }
1268
 
      return errno;
1269
 
    }
1270
 
    
1271
 
    struct argp argp = { .options = options, .parser = parse_opt,
1272
 
                         .args_doc = "",
1273
 
                         .doc = "Mandos client -- Get and decrypt"
1274
 
                         " passwords from a Mandos server" };
1275
 
    ret = argp_parse(&argp, argc, argv,
1276
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1277
 
    switch(ret){
1278
 
    case 0:
1279
 
      break;
1280
 
    case ENOMEM:
1281
 
    default:
1282
 
      errno = ret;
1283
 
      perror("argp_parse");
1284
 
      exitcode = EX_OSERR;
1285
 
      goto end;
1286
 
    case EINVAL:
1287
 
      exitcode = EX_USAGE;
1288
 
      goto end;
1289
 
    }
1290
 
  }
1291
 
  
1292
 
  if(not debug){
1293
 
    avahi_set_log_function(empty_log);
1294
 
  }
1295
 
 
1296
 
  if(interface[0] == '\0'){
1297
 
    struct dirent **direntries;
1298
 
    ret = scandir(sys_class_net, &direntries, good_interface,
1299
 
                  alphasort);
1300
 
    if(ret >= 1){
1301
 
      /* Pick the first good interface */
1302
 
      interface = strdup(direntries[0]->d_name);
1303
 
      if(debug){
1304
 
        fprintf(stderr, "Using interface \"%s\"\n", interface);
1305
 
      }
1306
 
      if(interface == NULL){
1307
 
        perror("malloc");
1308
 
        free(direntries);
1309
 
        exitcode = EXIT_FAILURE;
1310
 
        goto end;
1311
 
      }
1312
 
      free(direntries);
1313
 
    } else {
1314
 
      free(direntries);
1315
 
      fprintf(stderr, "Could not find a network interface\n");
1316
 
      exitcode = EXIT_FAILURE;
1317
 
      goto end;
1318
 
    }
1319
 
  }
1320
 
  
1321
 
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1322
 
     from the signal handler */
1323
 
  /* Initialize the pseudo-RNG for Avahi */
1324
 
  srand((unsigned int) time(NULL));
1325
 
  mc.simple_poll = avahi_simple_poll_new();
1326
 
  if(mc.simple_poll == NULL){
1327
 
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1328
 
    exitcode = EX_UNAVAILABLE;
1329
 
    goto end;
1330
 
  }
1331
 
  
1332
 
  sigemptyset(&sigterm_action.sa_mask);
1333
 
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1334
 
  if(ret == -1){
1335
 
    perror("sigaddset");
1336
 
    exitcode = EX_OSERR;
1337
 
    goto end;
1338
 
  }
1339
 
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1340
 
  if(ret == -1){
1341
 
    perror("sigaddset");
1342
 
    exitcode = EX_OSERR;
1343
 
    goto end;
1344
 
  }
1345
 
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1346
 
  if(ret == -1){
1347
 
    perror("sigaddset");
1348
 
    exitcode = EX_OSERR;
1349
 
    goto end;
1350
 
  }
1351
 
  /* Need to check if the handler is SIG_IGN before handling:
1352
 
     | [[info:libc:Initial Signal Actions]] |
1353
 
     | [[info:libc:Basic Signal Handling]]  |
1354
 
  */
1355
 
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1356
 
  if(ret == -1){
1357
 
    perror("sigaction");
1358
 
    return EX_OSERR;
1359
 
  }
1360
 
  if(old_sigterm_action.sa_handler != SIG_IGN){
1361
 
    ret = sigaction(SIGINT, &sigterm_action, NULL);
1362
 
    if(ret == -1){
1363
 
      perror("sigaction");
1364
 
      exitcode = EX_OSERR;
1365
 
      goto end;
1366
 
    }
1367
 
  }
1368
 
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1369
 
  if(ret == -1){
1370
 
    perror("sigaction");
1371
 
    return EX_OSERR;
1372
 
  }
1373
 
  if(old_sigterm_action.sa_handler != SIG_IGN){
1374
 
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
1375
 
    if(ret == -1){
1376
 
      perror("sigaction");
1377
 
      exitcode = EX_OSERR;
1378
 
      goto end;
1379
 
    }
1380
 
  }
1381
 
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1382
 
  if(ret == -1){
1383
 
    perror("sigaction");
1384
 
    return EX_OSERR;
1385
 
  }
1386
 
  if(old_sigterm_action.sa_handler != SIG_IGN){
1387
 
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
1388
 
    if(ret == -1){
1389
 
      perror("sigaction");
1390
 
      exitcode = EX_OSERR;
1391
 
      goto end;
1392
 
    }
1393
 
  }
1394
 
  
1395
 
  /* If the interface is down, bring it up */
1396
 
  if(strcmp(interface, "none") != 0){
 
716
        exit(EXIT_FAILURE);
 
717
      }
 
718
    }
 
719
    debug = debug_int ? true : false;
 
720
    
 
721
    pubkeyfile = combinepath(keydir, pubkeyfile);
 
722
    if (pubkeyfile == NULL){
 
723
      perror("combinepath");
 
724
      returncode = EXIT_FAILURE;
 
725
      goto exit;
 
726
    }
 
727
    
 
728
    seckeyfile = combinepath(keydir, seckeyfile);
 
729
    if (seckeyfile == NULL){
 
730
      perror("combinepath");
 
731
      goto exit;
 
732
    }
 
733
    
1397
734
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1398
735
    if(if_index == 0){
1399
736
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
1400
 
      exitcode = EX_UNAVAILABLE;
1401
 
      goto end;
1402
 
    }
1403
 
    
1404
 
    if(quit_now){
1405
 
      goto end;
1406
 
    }
1407
 
    
1408
 
    /* Re-raise priviliges */
1409
 
    errno = 0;
1410
 
    ret = seteuid(0);
1411
 
    if(ret == -1){
1412
 
      perror("seteuid");
1413
 
    }
1414
 
    
1415
 
#ifdef __linux__
1416
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1417
 
       messages about the network interface to mess up the prompt */
1418
 
    ret = klogctl(8, NULL, 5);
1419
 
    bool restore_loglevel = true;
1420
 
    if(ret == -1){
1421
 
      restore_loglevel = false;
1422
 
      perror("klogctl");
1423
 
    }
1424
 
#endif  /* __linux__ */
 
737
      exit(EXIT_FAILURE);
 
738
    }
 
739
    
 
740
    if(connect_to != NULL){
 
741
      /* Connect directly, do not use Zeroconf */
 
742
      /* (Mainly meant for debugging) */
 
743
      char *address = strrchr(connect_to, ':');
 
744
      if(address == NULL){
 
745
        fprintf(stderr, "No colon in address\n");
 
746
        exit(EXIT_FAILURE);
 
747
      }
 
748
      errno = 0;
 
749
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
 
750
      if(errno){
 
751
        perror("Bad port number");
 
752
        exit(EXIT_FAILURE);
 
753
      }
 
754
      *address = '\0';
 
755
      address = connect_to;
 
756
      ret = start_mandos_communication(address, port, if_index, &mc);
 
757
      if(ret < 0){
 
758
        exit(EXIT_FAILURE);
 
759
      } else {
 
760
        exit(EXIT_SUCCESS);
 
761
      }
 
762
    }
1425
763
    
1426
764
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1427
 
    if(sd < 0){
 
765
    if(sd < 0) {
1428
766
      perror("socket");
1429
 
      exitcode = EX_OSERR;
1430
 
#ifdef __linux__
1431
 
      if(restore_loglevel){
1432
 
        ret = klogctl(7, NULL, 0);
1433
 
        if(ret == -1){
1434
 
          perror("klogctl");
1435
 
        }
1436
 
      }
1437
 
#endif  /* __linux__ */
1438
 
      /* Lower privileges */
1439
 
      errno = 0;
1440
 
      ret = seteuid(uid);
1441
 
      if(ret == -1){
1442
 
        perror("seteuid");
1443
 
      }
1444
 
      goto end;
 
767
      returncode = EXIT_FAILURE;
 
768
      goto exit;
1445
769
    }
1446
 
    strcpy(network.ifr_name, interface);
 
770
    strcpy(network.ifr_name, interface); /* Spurious warning */
1447
771
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1448
772
    if(ret == -1){
 
773
      
1449
774
      perror("ioctl SIOCGIFFLAGS");
1450
 
#ifdef __linux__
1451
 
      if(restore_loglevel){
1452
 
        ret = klogctl(7, NULL, 0);
1453
 
        if(ret == -1){
1454
 
          perror("klogctl");
1455
 
        }
1456
 
      }
1457
 
#endif  /* __linux__ */
1458
 
      exitcode = EX_OSERR;
1459
 
      /* Lower privileges */
1460
 
      errno = 0;
1461
 
      ret = seteuid(uid);
1462
 
      if(ret == -1){
1463
 
        perror("seteuid");
1464
 
      }
1465
 
      goto end;
 
775
      returncode = EXIT_FAILURE;
 
776
      goto exit;
1466
777
    }
1467
778
    if((network.ifr_flags & IFF_UP) == 0){
1468
779
      network.ifr_flags |= IFF_UP;
1469
 
      take_down_interface = true;
1470
780
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1471
781
      if(ret == -1){
1472
 
        take_down_interface = false;
1473
 
        perror("ioctl SIOCSIFFLAGS +IFF_UP");
1474
 
        exitcode = EX_OSERR;
1475
 
#ifdef __linux__
1476
 
        if(restore_loglevel){
1477
 
          ret = klogctl(7, NULL, 0);
1478
 
          if(ret == -1){
1479
 
            perror("klogctl");
1480
 
          }
1481
 
        }
1482
 
#endif  /* __linux__ */
1483
 
        /* Lower privileges */
1484
 
        errno = 0;
1485
 
        ret = seteuid(uid);
1486
 
        if(ret == -1){
1487
 
          perror("seteuid");
1488
 
        }
1489
 
        goto end;
1490
 
      }
1491
 
    }
1492
 
    /* sleep checking until interface is running */
1493
 
    for(int i=0; i < delay * 4; i++){
1494
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1495
 
      if(ret == -1){
1496
 
        perror("ioctl SIOCGIFFLAGS");
1497
 
      } else if(network.ifr_flags & IFF_RUNNING){
1498
 
        break;
1499
 
      }
1500
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1501
 
      ret = nanosleep(&sleeptime, NULL);
1502
 
      if(ret == -1 and errno != EINTR){
1503
 
        perror("nanosleep");
1504
 
      }
1505
 
    }
1506
 
    if(not take_down_interface){
1507
 
      /* We won't need the socket anymore */
1508
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1509
 
      if(ret == -1){
1510
 
        perror("close");
1511
 
      }
1512
 
    }
1513
 
#ifdef __linux__
1514
 
    if(restore_loglevel){
1515
 
      /* Restores kernel loglevel to default */
1516
 
      ret = klogctl(7, NULL, 0);
1517
 
      if(ret == -1){
1518
 
        perror("klogctl");
1519
 
      }
1520
 
    }
1521
 
#endif  /* __linux__ */
1522
 
    /* Lower privileges */
1523
 
    errno = 0;
1524
 
    if(take_down_interface){
1525
 
      /* Lower privileges */
1526
 
      ret = seteuid(uid);
1527
 
      if(ret == -1){
1528
 
        perror("seteuid");
1529
 
      }
1530
 
    } else {
1531
 
      /* Lower privileges permanently */
1532
 
      ret = setuid(uid);
1533
 
      if(ret == -1){
1534
 
        perror("setuid");
1535
 
      }
1536
 
    }
1537
 
  }
1538
 
  
1539
 
  if(quit_now){
1540
 
    goto end;
1541
 
  }
1542
 
  
1543
 
  ret = init_gnutls_global(pubkey, seckey);
1544
 
  if(ret == -1){
1545
 
    fprintf(stderr, "init_gnutls_global failed\n");
1546
 
    exitcode = EX_UNAVAILABLE;
1547
 
    goto end;
1548
 
  } else {
1549
 
    gnutls_initialized = true;
1550
 
  }
1551
 
  
1552
 
  if(quit_now){
1553
 
    goto end;
1554
 
  }
1555
 
  
1556
 
  tempdir_created = true;
1557
 
  if(mkdtemp(tempdir) == NULL){
1558
 
    tempdir_created = false;
1559
 
    perror("mkdtemp");
1560
 
    goto end;
1561
 
  }
1562
 
  
1563
 
  if(quit_now){
1564
 
    goto end;
1565
 
  }
1566
 
  
1567
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
1568
 
    fprintf(stderr, "init_gpgme failed\n");
1569
 
    exitcode = EX_UNAVAILABLE;
1570
 
    goto end;
1571
 
  } else {
1572
 
    gpgme_initialized = true;
1573
 
  }
1574
 
  
1575
 
  if(quit_now){
1576
 
    goto end;
1577
 
  }
1578
 
  
1579
 
  if(connect_to != NULL){
1580
 
    /* Connect directly, do not use Zeroconf */
1581
 
    /* (Mainly meant for debugging) */
1582
 
    char *address = strrchr(connect_to, ':');
1583
 
    if(address == NULL){
1584
 
      fprintf(stderr, "No colon in address\n");
1585
 
      exitcode = EX_USAGE;
1586
 
      goto end;
1587
 
    }
1588
 
    
1589
 
    if(quit_now){
1590
 
      goto end;
1591
 
    }
1592
 
    
1593
 
    uint16_t port;
1594
 
    errno = 0;
1595
 
    tmpmax = strtoimax(address+1, &tmp, 10);
1596
 
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
1597
 
       or tmpmax != (uint16_t)tmpmax){
1598
 
      fprintf(stderr, "Bad port number\n");
1599
 
      exitcode = EX_USAGE;
1600
 
      goto end;
1601
 
    }
1602
 
  
1603
 
    if(quit_now){
1604
 
      goto end;
1605
 
    }
1606
 
    
1607
 
    port = (uint16_t)tmpmax;
1608
 
    *address = '\0';
1609
 
    address = connect_to;
1610
 
    /* Colon in address indicates IPv6 */
1611
 
    int af;
1612
 
    if(strchr(address, ':') != NULL){
1613
 
      af = AF_INET6;
1614
 
    } else {
1615
 
      af = AF_INET;
1616
 
    }
1617
 
    
1618
 
    if(quit_now){
1619
 
      goto end;
1620
 
    }
1621
 
    
1622
 
    ret = start_mandos_communication(address, port, if_index, af);
1623
 
    if(ret < 0){
1624
 
      switch(errno){
1625
 
      case ENETUNREACH:
1626
 
      case EHOSTDOWN:
1627
 
      case EHOSTUNREACH:
1628
 
        exitcode = EX_NOHOST;
1629
 
        break;
1630
 
      case EINVAL:
1631
 
        exitcode = EX_USAGE;
1632
 
        break;
1633
 
      case EIO:
1634
 
        exitcode = EX_IOERR;
1635
 
        break;
1636
 
      case EPROTO:
1637
 
        exitcode = EX_PROTOCOL;
1638
 
        break;
1639
 
      default:
1640
 
        exitcode = EX_OSERR;
1641
 
        break;
1642
 
      }
1643
 
    } else {
1644
 
      exitcode = EXIT_SUCCESS;
1645
 
    }
1646
 
    goto end;
1647
 
  }
1648
 
  
1649
 
  if(quit_now){
1650
 
    goto end;
1651
 
  }
1652
 
  
1653
 
  {
1654
 
    AvahiServerConfig config;
1655
 
    /* Do not publish any local Zeroconf records */
 
782
        perror("ioctl SIOCSIFFLAGS");
 
783
        returncode = EXIT_FAILURE;
 
784
        goto exit;
 
785
      }
 
786
    }
 
787
    close(sd);
 
788
    
 
789
    if (not debug){
 
790
      avahi_set_log_function(empty_log);
 
791
    }
 
792
    
 
793
    /* Initialize the psuedo-RNG */
 
794
    srand((unsigned int) time(NULL));
 
795
 
 
796
    /* Allocate main loop object */
 
797
    if (!(mc.simple_poll = avahi_simple_poll_new())) {
 
798
        fprintf(stderr, "Failed to create simple poll object.\n");
 
799
        returncode = EXIT_FAILURE;
 
800
        goto exit;
 
801
    }
 
802
 
 
803
    /* Do not publish any local records */
1656
804
    avahi_server_config_init(&config);
1657
805
    config.publish_hinfo = 0;
1658
806
    config.publish_addresses = 0;
1659
807
    config.publish_workstation = 0;
1660
808
    config.publish_domain = 0;
1661
 
    
 
809
 
1662
810
    /* Allocate a new server */
1663
 
    mc.server = avahi_server_new(avahi_simple_poll_get
1664
 
                                 (mc.simple_poll), &config, NULL,
1665
 
                                 NULL, &error);
 
811
    mc.server=avahi_server_new(avahi_simple_poll_get(mc.simple_poll),
 
812
                               &config, NULL, NULL, &error);
1666
813
    
1667
 
    /* Free the Avahi configuration data */
 
814
    /* Free the configuration data */
1668
815
    avahi_server_config_free(&config);
1669
 
  }
1670
 
  
1671
 
  /* Check if creating the Avahi server object succeeded */
1672
 
  if(mc.server == NULL){
1673
 
    fprintf(stderr, "Failed to create Avahi server: %s\n",
1674
 
            avahi_strerror(error));
1675
 
    exitcode = EX_UNAVAILABLE;
1676
 
    goto end;
1677
 
  }
1678
 
  
1679
 
  if(quit_now){
1680
 
    goto end;
1681
 
  }
1682
 
  
1683
 
  /* Create the Avahi service browser */
1684
 
  sb = avahi_s_service_browser_new(mc.server, if_index,
1685
 
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1686
 
                                   NULL, 0, browse_callback, NULL);
1687
 
  if(sb == NULL){
1688
 
    fprintf(stderr, "Failed to create service browser: %s\n",
1689
 
            avahi_strerror(avahi_server_errno(mc.server)));
1690
 
    exitcode = EX_UNAVAILABLE;
1691
 
    goto end;
1692
 
  }
1693
 
  
1694
 
  if(quit_now){
1695
 
    goto end;
1696
 
  }
1697
 
  
1698
 
  /* Run the main loop */
1699
 
  
1700
 
  if(debug){
1701
 
    fprintf(stderr, "Starting Avahi loop search\n");
1702
 
  }
1703
 
  
1704
 
  avahi_simple_poll_loop(mc.simple_poll);
1705
 
  
1706
 
 end:
1707
 
  
1708
 
  if(debug){
1709
 
    fprintf(stderr, "%s exiting\n", argv[0]);
1710
 
  }
1711
 
  
1712
 
  /* Cleanup things */
1713
 
  if(sb != NULL)
1714
 
    avahi_s_service_browser_free(sb);
1715
 
  
1716
 
  if(mc.server != NULL)
1717
 
    avahi_server_free(mc.server);
1718
 
  
1719
 
  if(mc.simple_poll != NULL)
1720
 
    avahi_simple_poll_free(mc.simple_poll);
1721
 
  
1722
 
  if(gnutls_initialized){
1723
 
    gnutls_certificate_free_credentials(mc.cred);
1724
 
    gnutls_global_deinit();
1725
 
    gnutls_dh_params_deinit(mc.dh_params);
1726
 
  }
1727
 
  
1728
 
  if(gpgme_initialized){
1729
 
    gpgme_release(mc.ctx);
1730
 
  }
1731
 
  
1732
 
  /* Take down the network interface */
1733
 
  if(take_down_interface){
1734
 
    /* Re-raise priviliges */
1735
 
    errno = 0;
1736
 
    ret = seteuid(0);
1737
 
    if(ret == -1){
1738
 
      perror("seteuid");
1739
 
    }
1740
 
    if(geteuid() == 0){
1741
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1742
 
      if(ret == -1){
1743
 
        perror("ioctl SIOCGIFFLAGS");
1744
 
      } else if(network.ifr_flags & IFF_UP) {
1745
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1746
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
1747
 
        if(ret == -1){
1748
 
          perror("ioctl SIOCSIFFLAGS -IFF_UP");
1749
 
        }
1750
 
      }
1751
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1752
 
      if(ret == -1){
1753
 
        perror("close");
1754
 
      }
1755
 
      /* Lower privileges permanently */
1756
 
      errno = 0;
1757
 
      ret = setuid(uid);
1758
 
      if(ret == -1){
1759
 
        perror("setuid");
1760
 
      }
1761
 
    }
1762
 
  }
1763
 
  
1764
 
  /* Removes the temp directory used by GPGME */
1765
 
  if(tempdir_created){
1766
 
    DIR *d;
1767
 
    struct dirent *direntry;
1768
 
    d = opendir(tempdir);
1769
 
    if(d == NULL){
1770
 
      if(errno != ENOENT){
1771
 
        perror("opendir");
1772
 
      }
1773
 
    } else {
1774
 
      while(true){
1775
 
        direntry = readdir(d);
1776
 
        if(direntry == NULL){
1777
 
          break;
1778
 
        }
1779
 
        /* Skip "." and ".." */
1780
 
        if(direntry->d_name[0] == '.'
1781
 
           and (direntry->d_name[1] == '\0'
1782
 
                or (direntry->d_name[1] == '.'
1783
 
                    and direntry->d_name[2] == '\0'))){
1784
 
          continue;
1785
 
        }
1786
 
        char *fullname = NULL;
1787
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
1788
 
                       direntry->d_name);
1789
 
        if(ret < 0){
1790
 
          perror("asprintf");
1791
 
          continue;
1792
 
        }
1793
 
        ret = remove(fullname);
1794
 
        if(ret == -1){
1795
 
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1796
 
                  strerror(errno));
1797
 
        }
1798
 
        free(fullname);
1799
 
      }
1800
 
      closedir(d);
1801
 
    }
1802
 
    ret = rmdir(tempdir);
1803
 
    if(ret == -1 and errno != ENOENT){
1804
 
      perror("rmdir");
1805
 
    }
1806
 
  }
1807
 
  
1808
 
  if(quit_now){
1809
 
    sigemptyset(&old_sigterm_action.sa_mask);
1810
 
    old_sigterm_action.sa_handler = SIG_DFL;
1811
 
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
1812
 
                                            &old_sigterm_action,
1813
 
                                            NULL));
1814
 
    if(ret == -1){
1815
 
      perror("sigaction");
1816
 
    }
1817
 
    do {
1818
 
      ret = raise(signal_received);
1819
 
    } while(ret != 0 and errno == EINTR);
1820
 
    if(ret != 0){
1821
 
      perror("raise");
1822
 
      abort();
1823
 
    }
1824
 
    TEMP_FAILURE_RETRY(pause());
1825
 
  }
1826
 
  
1827
 
  return exitcode;
 
816
    
 
817
    /* Check if creating the server object succeeded */
 
818
    if (!mc.server) {
 
819
        fprintf(stderr, "Failed to create server: %s\n",
 
820
                avahi_strerror(error));
 
821
        returncode = EXIT_FAILURE;
 
822
        goto exit;
 
823
    }
 
824
    
 
825
    /* Create the service browser */
 
826
    sb = avahi_s_service_browser_new(mc.server, if_index,
 
827
                                     AVAHI_PROTO_INET6,
 
828
                                     "_mandos._tcp", NULL, 0,
 
829
                                     browse_callback, &mc);
 
830
    if (!sb) {
 
831
        fprintf(stderr, "Failed to create service browser: %s\n",
 
832
                avahi_strerror(avahi_server_errno(mc.server)));
 
833
        returncode = EXIT_FAILURE;
 
834
        goto exit;
 
835
    }
 
836
    
 
837
    /* Run the main loop */
 
838
 
 
839
    if (debug){
 
840
      fprintf(stderr, "Starting avahi loop search\n");
 
841
    }
 
842
    
 
843
    avahi_simple_poll_loop(mc.simple_poll);
 
844
    
 
845
 exit:
 
846
 
 
847
    if (debug){
 
848
      fprintf(stderr, "%s exiting\n", argv[0]);
 
849
    }
 
850
    
 
851
    /* Cleanup things */
 
852
    if (sb)
 
853
        avahi_s_service_browser_free(sb);
 
854
    
 
855
    if (mc.server)
 
856
        avahi_server_free(mc.server);
 
857
 
 
858
    if (mc.simple_poll)
 
859
        avahi_simple_poll_free(mc.simple_poll);
 
860
    free(pubkeyfile);
 
861
    free(seckeyfile);
 
862
    
 
863
    return returncode;
1828
864
}