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
- browse files at revision 24.1.5
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.5
- Committer: Björn Påhlsson
- Date: 2008-07-31 16:20:47 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 30.
- Revision ID: belorn@braxen-20080731162047-lahe2b2prwjw8b2l
plugbasedclient:
Added support to disable plugins
Added support to change plugin directory
mandosclient.c
Fixed some funtion calls that lacked error handling
small bugfix
Added support to disable plugins
Added support to change plugin directory
mandosclient.c
Fixed some funtion calls that lacked error handling
small bugfix
- files added:
- ca.pem
- files removed:
- COPYING
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/password-request.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
plugins.d/mandosclient.c
8
8
* includes the following functions: "resolve_callback",
9
9
* "browse_callback", and parts of "main".
10
10
*
11
* Everything else is
12
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
11
* Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
12
* Påhlsson.
13
13
*
14
14
* This program is free software: you can redistribute it and/or
15
15
* modify it under the terms of the GNU General Public License as
25
25
* along with this program. If not, see
26
26
* <http://www.gnu.org/licenses/>.
27
27
*
28
* Contact the authors at <mandos@fukt.bsnet.se>.
28
* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
29
* <https://www.fukt.bsnet.se/~teddy/>.
29
30
*/
30
31
31
/* Needed by GPGME, specifically gpgme_data_seek() */
32
#define _FORTIFY_SOURCE 2
33
32
34
#define _LARGEFILE_SOURCE
33
35
#define _FILE_OFFSET_BITS 64
34
36
35
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
36
37
#include <stdio.h> /* fprintf(), stderr, fwrite(),
38
stdout, ferror() */
39
#include <stdint.h> /* uint16_t, uint32_t */
40
#include <stddef.h> /* NULL, size_t, ssize_t */
41
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
42
srand() */
43
#include <stdbool.h> /* bool, true */
44
#include <string.h> /* memset(), strcmp(), strlen(),
45
strerror(), asprintf(), strcpy() */
46
#include <sys/ioctl.h> /* ioctl */
47
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
48
sockaddr_in6, PF_INET6,
49
SOCK_STREAM, INET6_ADDRSTRLEN,
50
uid_t, gid_t */
51
#include <inttypes.h> /* PRIu16 */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton(),
54
connect() */
55
#include <assert.h> /* assert() */
56
#include <errno.h> /* perror(), errno */
57
#include <time.h> /* time() */
58
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
59
SIOCSIFFLAGS, if_indextoname(),
60
if_nametoindex(), IF_NAMESIZE */
61
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
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 */
67
#include <argp.h> /* struct argp_option, error_t, struct
68
argp_state, struct argp,
69
argp_parse(), ARGP_KEY_ARG,
70
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
71
72
/* Avahi */
73
/* All Avahi types, constants and functions
74
Avahi*, avahi_*,
75
AVAHI_* */
37
#include <stdio.h>
38
#include <assert.h>
39
#include <stdlib.h>
40
#include <time.h>
41
#include <net/if.h> /* if_nametoindex */
42
76
43
#include <avahi-core/core.h>
77
44
#include <avahi-core/lookup.h>
78
45
#include <avahi-core/log.h>
80
47
#include <avahi-common/malloc.h>
81
48
#include <avahi-common/error.h>
82
49
83
/* GnuTLS */
84
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
85
functions:
86
gnutls_*
87
init_gnutls_session(),
88
GNUTLS_* */
89
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
90
GNUTLS_OPENPGP_FMT_BASE64 */
91
92
/* GPGME */
93
#include <gpgme.h> /* All GPGME types, constants and
94
functions:
95
gpgme_*
96
GPGME_PROTOCOL_OpenPGP,
97
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>
98
70
99
71
#define BUFFER_SIZE 256
72
#define DH_BITS 1024
73
74
const char *certdir = "/conf/conf.d/cryptkeyreq/";
75
const char *certfile = "openpgp-client.txt";
76
const char *certkey = "openpgp-client-key.txt";
100
77
101
78
bool debug = false;
102
static const char *keydir = "/conf/conf.d/mandos";
103
static const char mandos_protocol_version[] = "1";
104
const char *argp_program_version = "password-request 1.0";
105
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
106
79
107
/* Used for passing in values through the Avahi callback functions */
108
80
typedef struct {
109
AvahiSimplePoll *simple_poll;
110
AvahiServer *server;
81
gnutls_session_t session;
111
82
gnutls_certificate_credentials_t cred;
112
unsigned int dh_bits;
113
83
gnutls_dh_params_t dh_params;
114
const char *priority;
115
} mandos_context;
116
117
/*
118
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
119
* "buffer_capacity" is how much is currently allocated,
120
* "buffer_length" is how much is already used.
121
*/
122
size_t adjustbuffer(char **buffer, size_t buffer_length,
123
size_t buffer_capacity){
124
if (buffer_length + BUFFER_SIZE > buffer_capacity){
125
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
126
if (buffer == NULL){
127
return 0;
128
}
129
buffer_capacity += BUFFER_SIZE;
130
}
131
return buffer_capacity;
132
}
133
134
/*
135
* Decrypt OpenPGP data using keyrings in HOMEDIR.
136
* Returns -1 on error
137
*/
138
static ssize_t pgp_packet_decrypt (const char *cryptotext,
139
size_t crypto_size,
140
char **plaintext,
141
const char *homedir){
84
} encrypted_session;
85
86
87
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet, const char *homedir){
142
89
gpgme_data_t dh_crypto, dh_plain;
143
90
gpgme_ctx_t ctx;
144
91
gpgme_error_t rc;
145
92
ssize_t ret;
146
size_t plaintext_capacity = 0;
147
ssize_t plaintext_length = 0;
93
ssize_t new_packet_capacity = 0;
94
ssize_t new_packet_length = 0;
148
95
gpgme_engine_info_t engine_info;
149
96
150
97
if (debug){
151
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
98
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
152
99
}
153
100
154
101
/* Init GPGME */
160
107
return -1;
161
108
}
162
109
163
/* Set GPGME home directory for the OpenPGP engine only */
110
/* Set GPGME home directory */
164
111
rc = gpgme_get_engine_info (&engine_info);
165
112
if (rc != GPG_ERR_NO_ERROR){
166
113
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
176
123
engine_info = engine_info->next;
177
124
}
178
125
if(engine_info == NULL){
179
fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
126
fprintf(stderr, "Could not set home dir to %s\n", homedir);
180
127
return -1;
181
128
}
182
129
183
/* Create new GPGME data buffer from memory cryptotext */
184
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
185
0);
130
/* Create new GPGME data buffer from packet buffer */
131
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
186
132
if (rc != GPG_ERR_NO_ERROR){
187
133
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
188
134
gpgme_strsource(rc), gpgme_strerror(rc));
194
140
if (rc != GPG_ERR_NO_ERROR){
195
141
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
196
142
gpgme_strsource(rc), gpgme_strerror(rc));
197
gpgme_data_release(dh_crypto);
198
143
return -1;
199
144
}
200
145
203
148
if (rc != GPG_ERR_NO_ERROR){
204
149
fprintf(stderr, "bad gpgme_new: %s: %s\n",
205
150
gpgme_strsource(rc), gpgme_strerror(rc));
206
plaintext_length = -1;
207
goto decrypt_end;
151
return -1;
208
152
}
209
153
210
/* Decrypt data from the cryptotext data buffer to the plaintext
211
data buffer */
154
/* Decrypt data from the FILE pointer to the plaintext data
155
buffer */
212
156
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
213
157
if (rc != GPG_ERR_NO_ERROR){
214
158
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
215
159
gpgme_strsource(rc), gpgme_strerror(rc));
216
plaintext_length = -1;
217
goto decrypt_end;
160
return -1;
218
161
}
219
162
220
163
if(debug){
221
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
164
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
222
165
}
223
166
224
167
if (debug){
225
168
gpgme_decrypt_result_t result;
226
169
result = gpgme_op_decrypt_result(ctx);
229
172
} else {
230
173
fprintf(stderr, "Unsupported algorithm: %s\n",
231
174
result->unsupported_algorithm);
232
fprintf(stderr, "Wrong key usage: %u\n",
175
fprintf(stderr, "Wrong key usage: %d\n",
233
176
result->wrong_key_usage);
234
177
if(result->file_name != NULL){
235
178
fprintf(stderr, "File name: %s\n", result->file_name);
250
193
}
251
194
}
252
195
196
/* Delete the GPGME FILE pointer cryptotext data buffer */
197
gpgme_data_release(dh_crypto);
198
253
199
/* Seek back to the beginning of the GPGME plaintext data buffer */
254
200
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
255
201
perror("pgpme_data_seek");
256
plaintext_length = -1;
257
goto decrypt_end;
258
202
}
259
203
260
*plaintext = NULL;
204
*new_packet = 0;
261
205
while(true){
262
plaintext_capacity = adjustbuffer(plaintext,
263
(size_t)plaintext_length,
264
plaintext_capacity);
265
if (plaintext_capacity == 0){
266
perror("adjustbuffer");
267
plaintext_length = -1;
268
goto decrypt_end;
206
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
207
*new_packet = realloc(*new_packet,
208
(unsigned int)new_packet_capacity
209
+ BUFFER_SIZE);
210
if (*new_packet == NULL){
211
perror("realloc");
212
return -1;
213
}
214
new_packet_capacity += BUFFER_SIZE;
269
215
}
270
216
271
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
217
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
272
218
BUFFER_SIZE);
273
219
/* Print the data, if any */
274
220
if (ret == 0){
275
/* EOF */
276
221
break;
277
222
}
278
223
if(ret < 0){
279
224
perror("gpgme_data_read");
280
plaintext_length = -1;
281
goto decrypt_end;
225
return -1;
282
226
}
283
plaintext_length += ret;
227
new_packet_length += ret;
284
228
}
285
229
286
if(debug){
287
fprintf(stderr, "Decrypted password is: ");
288
for(ssize_t i = 0; i < plaintext_length; i++){
289
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
290
}
291
fprintf(stderr, "\n");
292
}
293
294
decrypt_end:
295
296
/* Delete the GPGME cryptotext data buffer */
297
gpgme_data_release(dh_crypto);
230
/* FIXME: check characters before printing to screen so to not print
231
terminal control characters */
232
/* if(debug){ */
233
/* fprintf(stderr, "decrypted password is: "); */
234
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
235
/* fprintf(stderr, "\n"); */
236
/* } */
298
237
299
238
/* Delete the GPGME plaintext data buffer */
300
239
gpgme_data_release(dh_plain);
301
return plaintext_length;
240
return new_packet_length;
302
241
}
303
242
304
243
static const char * safer_gnutls_strerror (int value) {
305
const char *ret = gnutls_strerror (value); /* Spurious warning */
244
const char *ret = gnutls_strerror (value);
306
245
if (ret == NULL)
307
246
ret = "(unknown)";
308
247
return ret;
309
248
}
310
249
311
/* GnuTLS log function callback */
312
static void debuggnutls(__attribute__((unused)) int level,
313
const char* string){
314
fprintf(stderr, "GnuTLS: %s", string);
250
void debuggnutls(__attribute__((unused)) int level,
251
const char* string){
252
fprintf(stderr, "%s", string);
315
253
}
316
254
317
static int init_gnutls_global(mandos_context *mc,
318
const char *pubkeyfilename,
319
const char *seckeyfilename){
255
int initgnutls(encrypted_session *es){
256
const char *err;
320
257
int ret;
321
258
322
259
if(debug){
323
260
fprintf(stderr, "Initializing GnuTLS\n");
324
261
}
325
326
ret = gnutls_global_init();
327
if (ret != GNUTLS_E_SUCCESS) {
328
fprintf (stderr, "GnuTLS global_init: %s\n",
329
safer_gnutls_strerror(ret));
262
263
if ((ret = gnutls_global_init ())
264
!= GNUTLS_E_SUCCESS) {
265
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
330
266
return -1;
331
267
}
332
268
333
269
if (debug){
334
/* "Use a log level over 10 to enable all debugging options."
335
* - GnuTLS manual
336
*/
337
270
gnutls_global_set_log_level(11);
338
271
gnutls_global_set_log_function(debuggnutls);
339
272
}
340
273
341
/* OpenPGP credentials */
342
gnutls_certificate_allocate_credentials(&mc->cred);
343
if (ret != GNUTLS_E_SUCCESS){
344
fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
345
warning */
274
/* openpgp credentials */
275
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
276
!= GNUTLS_E_SUCCESS) {
277
fprintf (stderr, "memory error: %s\n",
346
278
safer_gnutls_strerror(ret));
347
gnutls_global_deinit ();
348
279
return -1;
349
280
}
350
281
351
282
if(debug){
352
283
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
353
" and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
354
seckeyfilename);
284
" and keyfile %s as GnuTLS credentials\n", certfile,
285
certkey);
355
286
}
356
287
357
288
ret = gnutls_certificate_set_openpgp_key_file
358
(mc->cred, pubkeyfilename, seckeyfilename,
359
GNUTLS_OPENPGP_FMT_BASE64);
289
(es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
360
290
if (ret != GNUTLS_E_SUCCESS) {
361
fprintf(stderr,
362
"Error[%d] while reading the OpenPGP key pair ('%s',"
363
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
364
fprintf(stdout, "The GnuTLS error is: %s\n",
291
fprintf
292
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
293
" '%s')\n",
294
ret, certfile, certkey);
295
fprintf(stdout, "The Error is: %s\n",
365
296
safer_gnutls_strerror(ret));
366
goto globalfail;
367
}
368
369
/* GnuTLS server initialization */
370
ret = gnutls_dh_params_init(&mc->dh_params);
371
if (ret != GNUTLS_E_SUCCESS) {
372
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
373
" %s\n", safer_gnutls_strerror(ret));
374
goto globalfail;
375
}
376
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
377
if (ret != GNUTLS_E_SUCCESS) {
378
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
379
safer_gnutls_strerror(ret));
380
goto globalfail;
381
}
382
383
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
384
385
return 0;
386
387
globalfail:
388
389
gnutls_certificate_free_credentials(mc->cred);
390
gnutls_global_deinit();
391
return -1;
392
393
}
394
395
static int init_gnutls_session(mandos_context *mc,
396
gnutls_session_t *session){
397
int ret;
398
/* GnuTLS session creation */
399
ret = gnutls_init(session, GNUTLS_SERVER);
400
if (ret != GNUTLS_E_SUCCESS){
297
return -1;
298
}
299
300
//GnuTLS server initialization
301
if ((ret = gnutls_dh_params_init (&es->dh_params))
302
!= GNUTLS_E_SUCCESS) {
303
fprintf (stderr, "Error in dh parameter initialization: %s\n",
304
safer_gnutls_strerror(ret));
305
return -1;
306
}
307
308
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
309
!= GNUTLS_E_SUCCESS) {
310
fprintf (stderr, "Error in prime generation: %s\n",
311
safer_gnutls_strerror(ret));
312
return -1;
313
}
314
315
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
316
317
// GnuTLS session creation
318
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
319
!= GNUTLS_E_SUCCESS){
401
320
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
402
321
safer_gnutls_strerror(ret));
403
322
}
404
323
405
{
406
const char *err;
407
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
408
if (ret != GNUTLS_E_SUCCESS) {
409
fprintf(stderr, "Syntax error at: %s\n", err);
410
fprintf(stderr, "GnuTLS error: %s\n",
411
safer_gnutls_strerror(ret));
412
gnutls_deinit (*session);
413
return -1;
414
}
324
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
325
!= GNUTLS_E_SUCCESS) {
326
fprintf(stderr, "Syntax error at: %s\n", err);
327
fprintf(stderr, "GnuTLS error: %s\n",
328
safer_gnutls_strerror(ret));
329
return -1;
415
330
}
416
331
417
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
418
mc->cred);
419
if (ret != GNUTLS_E_SUCCESS) {
420
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
332
if ((ret = gnutls_credentials_set
333
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
334
!= GNUTLS_E_SUCCESS) {
335
fprintf(stderr, "Error setting a credentials set: %s\n",
421
336
safer_gnutls_strerror(ret));
422
gnutls_deinit (*session);
423
337
return -1;
424
338
}
425
339
426
340
/* ignore client certificate if any. */
427
gnutls_certificate_server_set_request (*session,
341
gnutls_certificate_server_set_request (es->session,
428
342
GNUTLS_CERT_IGNORE);
429
343
430
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
344
gnutls_dh_set_prime_bits (es->session, DH_BITS);
431
345
432
346
return 0;
433
347
}
434
348
435
/* Avahi log function callback */
436
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
437
__attribute__((unused)) const char *txt){}
349
void empty_log(__attribute__((unused)) AvahiLogLevel level,
350
__attribute__((unused)) const char *txt){}
438
351
439
/* Called when a Mandos server is found */
440
static int start_mandos_communication(const char *ip, uint16_t port,
441
AvahiIfIndex if_index,
442
mandos_context *mc){
352
int start_mandos_communication(const char *ip, uint16_t port,
353
unsigned int if_index){
443
354
int ret, tcp_sd;
444
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
355
struct sockaddr_in6 to;
356
encrypted_session es;
445
357
char *buffer = NULL;
446
358
char *decrypted_buffer;
447
359
size_t buffer_length = 0;
448
360
size_t buffer_capacity = 0;
449
361
ssize_t decrypted_buffer_size;
450
size_t written;
362
size_t written = 0;
451
363
int retval = 0;
452
364
char interface[IF_NAMESIZE];
453
gnutls_session_t session;
454
455
ret = init_gnutls_session (mc, &session);
456
if (ret != 0){
457
return -1;
458
}
459
365
460
366
if(debug){
461
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
462
"\n", ip, port);
367
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
463
368
}
464
369
465
370
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
467
372
perror("socket");
468
373
return -1;
469
374
}
470
471
if(debug){
472
if(if_indextoname((unsigned int)if_index, interface) == NULL){
375
376
if(if_indextoname(if_index, interface) == NULL){
377
if(debug){
473
378
perror("if_indextoname");
474
return -1;
475
379
}
380
return -1;
381
}
382
383
if(debug){
476
384
fprintf(stderr, "Binding to interface %s\n", interface);
477
385
}
478
386
479
memset(&to, 0, sizeof(to));
480
to.in6.sin6_family = AF_INET6;
481
/* It would be nice to have a way to detect if we were passed an
482
IPv4 address here. Now we assume an IPv6 address. */
483
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
387
memset(&to,0,sizeof(to)); /* Spurious warning */
388
to.sin6_family = AF_INET6;
389
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
484
390
if (ret < 0 ){
485
391
perror("inet_pton");
486
392
return -1;
487
}
393
}
488
394
if(ret == 0){
489
395
fprintf(stderr, "Bad address: %s\n", ip);
490
396
return -1;
491
397
}
492
to.in6.sin6_port = htons(port); /* Spurious warning */
398
to.sin6_port = htons(port); /* Spurious warning */
493
399
494
to.in6.sin6_scope_id = (uint32_t)if_index;
400
to.sin6_scope_id = (uint32_t)if_index;
495
401
496
402
if(debug){
497
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
498
port);
499
char addrstr[INET6_ADDRSTRLEN] = "";
500
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
501
sizeof(addrstr)) == NULL){
502
perror("inet_ntop");
503
} else {
504
if(strcmp(addrstr, ip) != 0){
505
fprintf(stderr, "Canonical address form: %s\n", addrstr);
506
}
507
}
403
fprintf(stderr, "Connection to: %s\n", ip);
508
404
}
509
405
510
ret = connect(tcp_sd, &to.in, sizeof(to));
406
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
511
407
if (ret < 0){
512
408
perror("connect");
513
409
return -1;
514
410
}
515
516
const char *out = mandos_protocol_version;
517
written = 0;
518
while (true){
519
size_t out_size = strlen(out);
520
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
521
out_size - written));
522
if (ret == -1){
523
perror("write");
524
retval = -1;
525
goto mandos_end;
526
}
527
written += (size_t)ret;
528
if(written < out_size){
529
continue;
530
} else {
531
if (out == mandos_protocol_version){
532
written = 0;
533
out = "\r\n";
534
} else {
535
break;
536
}
537
}
411
412
ret = initgnutls (&es);
413
if (ret != 0){
414
retval = -1;
415
return -1;
538
416
}
539
417
418
gnutls_transport_set_ptr (es.session,
419
(gnutls_transport_ptr_t) tcp_sd);
420
540
421
if(debug){
541
422
fprintf(stderr, "Establishing TLS session with %s\n", ip);
542
423
}
543
424
544
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
545
546
do{
547
ret = gnutls_handshake (session);
548
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
425
ret = gnutls_handshake (es.session);
549
426
550
427
if (ret != GNUTLS_E_SUCCESS){
551
428
if(debug){
552
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
429
fprintf(stderr, "\n*** Handshake failed ***\n");
553
430
gnutls_perror (ret);
554
431
}
555
432
retval = -1;
556
goto mandos_end;
433
goto exit;
557
434
}
558
435
559
/* Read OpenPGP packet that contains the wanted password */
436
//Retrieve OpenPGP packet that contains the wanted password
560
437
561
438
if(debug){
562
439
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
564
441
}
565
442
566
443
while(true){
567
buffer_capacity = adjustbuffer(&buffer, buffer_length,
568
buffer_capacity);
569
if (buffer_capacity == 0){
570
perror("adjustbuffer");
571
retval = -1;
572
goto mandos_end;
444
if (buffer_length + BUFFER_SIZE > buffer_capacity){
445
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
446
if (buffer == NULL){
447
perror("realloc");
448
goto exit;
449
}
450
buffer_capacity += BUFFER_SIZE;
573
451
}
574
452
575
ret = gnutls_record_recv(session, buffer+buffer_length,
576
BUFFER_SIZE);
453
ret = gnutls_record_recv
454
(es.session, buffer+buffer_length, BUFFER_SIZE);
577
455
if (ret == 0){
578
456
break;
579
457
}
583
461
case GNUTLS_E_AGAIN:
584
462
break;
585
463
case GNUTLS_E_REHANDSHAKE:
586
do{
587
ret = gnutls_handshake (session);
588
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
464
ret = gnutls_handshake (es.session);
589
465
if (ret < 0){
590
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
466
fprintf(stderr, "\n*** Handshake failed ***\n");
591
467
gnutls_perror (ret);
592
468
retval = -1;
593
goto mandos_end;
469
goto exit;
594
470
}
595
471
break;
596
472
default:
597
473
fprintf(stderr, "Unknown error while reading data from"
598
" encrypted session with Mandos server\n");
474
" encrypted session with mandos server\n");
599
475
retval = -1;
600
gnutls_bye (session, GNUTLS_SHUT_RDWR);
601
goto mandos_end;
476
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
477
goto exit;
602
478
}
603
479
} else {
604
480
buffer_length += (size_t) ret;
605
481
}
606
482
}
607
483
608
if(debug){
609
fprintf(stderr, "Closing TLS session\n");
610
}
611
612
gnutls_bye (session, GNUTLS_SHUT_RDWR);
613
614
484
if (buffer_length > 0){
615
485
decrypted_buffer_size = pgp_packet_decrypt(buffer,
616
486
buffer_length,
617
487
&decrypted_buffer,
618
keydir);
488
certdir);
619
489
if (decrypted_buffer_size >= 0){
620
written = 0;
621
while(written < (size_t) decrypted_buffer_size){
490
while(written < decrypted_buffer_size){
622
491
ret = (int)fwrite (decrypted_buffer + written, 1,
623
492
(size_t)decrypted_buffer_size - written,
624
493
stdout);
637
506
retval = -1;
638
507
}
639
508
}
640
641
/* Shutdown procedure */
642
643
mandos_end:
509
510
//shutdown procedure
511
512
if(debug){
513
fprintf(stderr, "Closing TLS session\n");
514
}
515
644
516
free(buffer);
517
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
518
exit:
645
519
close(tcp_sd);
646
gnutls_deinit (session);
520
gnutls_deinit (es.session);
521
gnutls_certificate_free_credentials (es.cred);
522
gnutls_global_deinit ();
647
523
return retval;
648
524
}
649
525
650
static void resolve_callback(AvahiSServiceResolver *r,
651
AvahiIfIndex interface,
652
AVAHI_GCC_UNUSED AvahiProtocol protocol,
653
AvahiResolverEvent event,
654
const char *name,
655
const char *type,
656
const char *domain,
657
const char *host_name,
658
const AvahiAddress *address,
659
uint16_t port,
660
AVAHI_GCC_UNUSED AvahiStringList *txt,
661
AVAHI_GCC_UNUSED AvahiLookupResultFlags
662
flags,
663
void* userdata) {
664
mandos_context *mc = userdata;
665
assert(r);
526
static AvahiSimplePoll *simple_poll = NULL;
527
static AvahiServer *server = NULL;
528
529
static void resolve_callback(
530
AvahiSServiceResolver *r,
531
AvahiIfIndex interface,
532
AVAHI_GCC_UNUSED AvahiProtocol protocol,
533
AvahiResolverEvent event,
534
const char *name,
535
const char *type,
536
const char *domain,
537
const char *host_name,
538
const AvahiAddress *address,
539
uint16_t port,
540
AVAHI_GCC_UNUSED AvahiStringList *txt,
541
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
542
AVAHI_GCC_UNUSED void* userdata) {
543
544
assert(r); /* Spurious warning */
666
545
667
546
/* Called whenever a service has been resolved successfully or
668
547
timed out */
670
549
switch (event) {
671
550
default:
672
551
case AVAHI_RESOLVER_FAILURE:
673
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
674
" of type '%s' in domain '%s': %s\n", name, type, domain,
675
avahi_strerror(avahi_server_errno(mc->server)));
552
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
553
" type '%s' in domain '%s': %s\n", name, type, domain,
554
avahi_strerror(avahi_server_errno(server)));
676
555
break;
677
556
678
557
case AVAHI_RESOLVER_FOUND:
680
559
char ip[AVAHI_ADDRESS_STR_MAX];
681
560
avahi_address_snprint(ip, sizeof(ip), address);
682
561
if(debug){
683
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
684
PRIu16 ") on port %d\n", name, host_name, ip,
685
interface, port);
562
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
563
" port %d\n", name, host_name, ip, port);
686
564
}
687
int ret = start_mandos_communication(ip, port, interface, mc);
565
int ret = start_mandos_communication(ip, port,
566
(unsigned int) interface);
688
567
if (ret == 0){
689
avahi_simple_poll_quit(mc->simple_poll);
568
exit(EXIT_SUCCESS);
690
569
}
691
570
}
692
571
}
693
572
avahi_s_service_resolver_free(r);
694
573
}
695
574
696
static void browse_callback( AvahiSServiceBrowser *b,
697
AvahiIfIndex interface,
698
AvahiProtocol protocol,
699
AvahiBrowserEvent event,
700
const char *name,
701
const char *type,
702
const char *domain,
703
AVAHI_GCC_UNUSED AvahiLookupResultFlags
704
flags,
705
void* userdata) {
706
mandos_context *mc = userdata;
707
assert(b);
708
709
/* Called whenever a new services becomes available on the LAN or
710
is removed from the LAN */
711
712
switch (event) {
713
default:
714
case AVAHI_BROWSER_FAILURE:
715
716
fprintf(stderr, "(Avahi browser) %s\n",
717
avahi_strerror(avahi_server_errno(mc->server)));
718
avahi_simple_poll_quit(mc->simple_poll);
719
return;
720
721
case AVAHI_BROWSER_NEW:
722
/* We ignore the returned Avahi resolver object. In the callback
723
function we free it. If the Avahi server is terminated before
724
the callback function is called the Avahi server will free the
725
resolver for us. */
726
727
if (!(avahi_s_service_resolver_new(mc->server, interface,
728
protocol, name, type, domain,
729
AVAHI_PROTO_INET6, 0,
730
resolve_callback, mc)))
731
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
732
name, avahi_strerror(avahi_server_errno(mc->server)));
733
break;
734
735
case AVAHI_BROWSER_REMOVE:
736
break;
737
738
case AVAHI_BROWSER_ALL_FOR_NOW:
739
case AVAHI_BROWSER_CACHE_EXHAUSTED:
740
if(debug){
741
fprintf(stderr, "No Mandos server found, still searching...\n");
575
static void browse_callback(
576
AvahiSServiceBrowser *b,
577
AvahiIfIndex interface,
578
AvahiProtocol protocol,
579
AvahiBrowserEvent event,
580
const char *name,
581
const char *type,
582
const char *domain,
583
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
584
void* userdata) {
585
586
AvahiServer *s = userdata;
587
assert(b); /* Spurious warning */
588
589
/* Called whenever a new services becomes available on the LAN or
590
is removed from the LAN */
591
592
switch (event) {
593
default:
594
case AVAHI_BROWSER_FAILURE:
595
596
fprintf(stderr, "(Browser) %s\n",
597
avahi_strerror(avahi_server_errno(server)));
598
avahi_simple_poll_quit(simple_poll);
599
return;
600
601
case AVAHI_BROWSER_NEW:
602
/* We ignore the returned resolver object. In the callback
603
function we free it. If the server is terminated before
604
the callback function is called the server will free
605
the resolver for us. */
606
607
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
608
type, domain,
609
AVAHI_PROTO_INET6, 0,
610
resolve_callback, s)))
611
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
612
avahi_strerror(avahi_server_errno(s)));
613
break;
614
615
case AVAHI_BROWSER_REMOVE:
616
break;
617
618
case AVAHI_BROWSER_ALL_FOR_NOW:
619
case AVAHI_BROWSER_CACHE_EXHAUSTED:
620
break;
742
621
}
743
break;
744
}
745
622
}
746
623
747
/* Combines file name and path and returns the malloced new
748
string. some sane checks could/should be added */
749
static char *combinepath(const char *first, const char *second){
624
/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */
625
const char *combinepath(const char *first, const char *second){
750
626
char *tmp;
751
int ret = asprintf(&tmp, "%s/%s", first, second);
752
if(ret < 0){
627
tmp = malloc(strlen(first) + strlen(second) + 2);
628
if (tmp == NULL){
629
perror("malloc");
753
630
return NULL;
754
631
}
632
strcpy(tmp, first);
633
if (first[0] != '\0' and first[strlen(first) - 1] != '/'){
634
strcat(tmp, "/");
635
}
636
strcat(tmp, second);
755
637
return tmp;
756
638
}
757
639
758
640
759
int main(int argc, char *argv[]){
641
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
642
AvahiServerConfig config;
760
643
AvahiSServiceBrowser *sb = NULL;
761
644
int error;
762
645
int ret;
763
int exitcode = EXIT_SUCCESS;
646
int returncode = EXIT_SUCCESS;
764
647
const char *interface = "eth0";
765
struct ifreq network;
766
int sd;
767
uid_t uid;
768
gid_t gid;
769
char *connect_to = NULL;
770
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
771
char *pubkeyfilename = NULL;
772
char *seckeyfilename = NULL;
773
const char *pubkeyname = "pubkey.txt";
774
const char *seckeyname = "seckey.txt";
775
mandos_context mc = { .simple_poll = NULL, .server = NULL,
776
.dh_bits = 1024, .priority = "SECURE256"};
777
bool gnutls_initalized = false;
778
779
{
780
struct argp_option options[] = {
781
{ .name = "debug", .key = 128,
782
.doc = "Debug mode", .group = 3 },
783
{ .name = "connect", .key = 'c',
784
.arg = "IP",
785
.doc = "Connect directly to a sepcified mandos server",
786
.group = 1 },
787
{ .name = "interface", .key = 'i',
788
.arg = "INTERFACE",
789
.doc = "Interface that Avahi will conntect through",
790
.group = 1 },
791
{ .name = "keydir", .key = 'd',
792
.arg = "KEYDIR",
793
.doc = "Directory where the openpgp keyring is",
794
.group = 1 },
795
{ .name = "seckey", .key = 's',
796
.arg = "SECKEY",
797
.doc = "Secret openpgp key for gnutls authentication",
798
.group = 1 },
799
{ .name = "pubkey", .key = 'p',
800
.arg = "PUBKEY",
801
.doc = "Public openpgp key for gnutls authentication",
802
.group = 2 },
803
{ .name = "dh-bits", .key = 129,
804
.arg = "BITS",
805
.doc = "dh-bits to use in gnutls communication",
806
.group = 2 },
807
{ .name = "priority", .key = 130,
808
.arg = "PRIORITY",
809
.doc = "GNUTLS priority", .group = 1 },
810
{ .name = NULL }
811
};
812
813
814
error_t parse_opt (int key, char *arg,
815
struct argp_state *state) {
816
/* Get the INPUT argument from `argp_parse', which we know is
817
a pointer to our plugin list pointer. */
818
switch (key) {
819
case 128:
820
debug = true;
821
break;
822
case 'c':
823
connect_to = arg;
824
break;
825
case 'i':
826
interface = arg;
827
break;
828
case 'd':
829
keydir = arg;
830
break;
831
case 's':
832
seckeyname = arg;
833
break;
834
case 'p':
835
pubkeyname = arg;
836
break;
837
case 129:
838
errno = 0;
839
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
840
if (errno){
841
perror("strtol");
842
exit(EXIT_FAILURE);
843
}
844
break;
845
case 130:
846
mc.priority = arg;
847
break;
848
case ARGP_KEY_ARG:
849
argp_usage (state);
850
case ARGP_KEY_END:
851
break;
852
default:
853
return ARGP_ERR_UNKNOWN;
854
}
855
return 0;
856
}
857
858
struct argp argp = { .options = options, .parser = parse_opt,
859
.args_doc = "",
860
.doc = "Mandos client -- Get and decrypt"
861
" passwords from mandos server" };
862
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
863
if (ret == ARGP_ERR_UNKNOWN){
864
fprintf(stderr, "Unknown error while parsing arguments\n");
865
exitcode = EXIT_FAILURE;
866
goto end;
867
}
868
}
869
870
pubkeyfilename = combinepath(keydir, pubkeyname);
871
if (pubkeyfilename == NULL){
872
perror("combinepath");
873
exitcode = EXIT_FAILURE;
874
goto end;
875
}
876
877
seckeyfilename = combinepath(keydir, seckeyname);
878
if (seckeyfilename == NULL){
879
perror("combinepath");
880
exitcode = EXIT_FAILURE;
881
goto end;
882
}
883
884
ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
885
if (ret == -1){
886
fprintf(stderr, "init_gnutls_global failed\n");
887
exitcode = EXIT_FAILURE;
888
goto end;
889
} else {
890
gnutls_initalized = true;
891
}
892
893
/* If the interface is down, bring it up */
894
{
895
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
896
if(sd < 0) {
897
perror("socket");
898
exitcode = EXIT_FAILURE;
899
goto end;
900
}
901
strcpy(network.ifr_name, interface);
902
ret = ioctl(sd, SIOCGIFFLAGS, &network);
903
if(ret == -1){
904
perror("ioctl SIOCGIFFLAGS");
905
exitcode = EXIT_FAILURE;
906
goto end;
907
}
908
if((network.ifr_flags & IFF_UP) == 0){
909
network.ifr_flags |= IFF_UP;
910
ret = ioctl(sd, SIOCSIFFLAGS, &network);
911
if(ret == -1){
912
perror("ioctl SIOCSIFFLAGS");
913
exitcode = EXIT_FAILURE;
914
goto end;
915
}
916
}
917
close(sd);
918
}
919
920
uid = getuid();
921
gid = getgid();
922
923
ret = setuid(uid);
924
if (ret == -1){
925
perror("setuid");
926
}
927
928
setgid(gid);
929
if (ret == -1){
930
perror("setgid");
931
}
932
933
if_index = (AvahiIfIndex) if_nametoindex(interface);
934
if(if_index == 0){
935
fprintf(stderr, "No such interface: \"%s\"\n", interface);
936
exit(EXIT_FAILURE);
937
}
938
939
if(connect_to != NULL){
940
/* Connect directly, do not use Zeroconf */
941
/* (Mainly meant for debugging) */
942
char *address = strrchr(connect_to, ':');
943
if(address == NULL){
944
fprintf(stderr, "No colon in address\n");
945
exitcode = EXIT_FAILURE;
946
goto end;
947
}
948
errno = 0;
949
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
950
if(errno){
951
perror("Bad port number");
952
exitcode = EXIT_FAILURE;
953
goto end;
954
}
955
*address = '\0';
956
address = connect_to;
957
ret = start_mandos_communication(address, port, if_index, &mc);
958
if(ret < 0){
959
exitcode = EXIT_FAILURE;
960
} else {
961
exitcode = EXIT_SUCCESS;
962
}
963
goto end;
964
}
965
648
649
while (true){
650
static struct option long_options[] = {
651
{"debug", no_argument, (int *)&debug, 1},
652
{"interface", required_argument, 0, 'i'},
653
{"certdir", required_argument, 0, 'd'},
654
{"certkey", required_argument, 0, 'c'},
655
{"certfile", required_argument, 0, 'k'},
656
{0, 0, 0, 0} };
657
658
int option_index = 0;
659
ret = getopt_long (argc, argv, "i:", long_options,
660
&option_index);
661
662
if (ret == -1){
663
break;
664
}
665
666
switch(ret){
667
case 0:
668
break;
669
case 'i':
670
interface = optarg;
671
break;
672
case 'd':
673
certdir = optarg;
674
break;
675
case 'c':
676
certfile = optarg;
677
break;
678
case 'k':
679
certkey = optarg;
680
break;
681
default:
682
exit(EXIT_FAILURE);
683
}
684
}
685
686
certfile = combinepath(certdir, certfile);
687
if (certfile == NULL){
688
goto exit;
689
}
690
691
certkey = combinepath(certdir, certkey);
692
if (certkey == NULL){
693
goto exit;
694
}
695
966
696
if (not debug){
967
697
avahi_set_log_function(empty_log);
968
698
}
969
699
970
/* Initialize the pseudo-RNG for Avahi */
700
/* Initialize the psuedo-RNG */
971
701
srand((unsigned int) time(NULL));
972
973
/* Allocate main Avahi loop object */
974
mc.simple_poll = avahi_simple_poll_new();
975
if (mc.simple_poll == NULL) {
976
fprintf(stderr, "Avahi: Failed to create simple poll"
977
" object.\n");
978
exitcode = EXIT_FAILURE;
979
goto end;
980
}
981
982
{
983
AvahiServerConfig config;
984
/* Do not publish any local Zeroconf records */
985
avahi_server_config_init(&config);
986
config.publish_hinfo = 0;
987
config.publish_addresses = 0;
988
config.publish_workstation = 0;
989
config.publish_domain = 0;
990
991
/* Allocate a new server */
992
mc.server = avahi_server_new(avahi_simple_poll_get
993
(mc.simple_poll), &config, NULL,
994
NULL, &error);
995
996
/* Free the Avahi configuration data */
997
avahi_server_config_free(&config);
998
}
999
1000
/* Check if creating the Avahi server object succeeded */
1001
if (mc.server == NULL) {
1002
fprintf(stderr, "Failed to create Avahi server: %s\n",
702
703
/* Allocate main loop object */
704
if (!(simple_poll = avahi_simple_poll_new())) {
705
fprintf(stderr, "Failed to create simple poll object.\n");
706
707
goto exit;
708
}
709
710
/* Do not publish any local records */
711
avahi_server_config_init(&config);
712
config.publish_hinfo = 0;
713
config.publish_addresses = 0;
714
config.publish_workstation = 0;
715
config.publish_domain = 0;
716
717
/* Allocate a new server */
718
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
719
&config, NULL, NULL, &error);
720
721
/* Free the configuration data */
722
avahi_server_config_free(&config);
723
724
/* Check if creating the server object succeeded */
725
if (!server) {
726
fprintf(stderr, "Failed to create server: %s\n",
1003
727
avahi_strerror(error));
1004
exitcode = EXIT_FAILURE;
1005
goto end;
728
returncode = EXIT_FAILURE;
729
goto exit;
1006
730
}
1007
731
1008
/* Create the Avahi service browser */
1009
sb = avahi_s_service_browser_new(mc.server, if_index,
732
/* Create the service browser */
733
sb = avahi_s_service_browser_new(server,
734
(AvahiIfIndex)
735
if_nametoindex(interface),
1010
736
AVAHI_PROTO_INET6,
1011
737
"_mandos._tcp", NULL, 0,
1012
browse_callback, &mc);
1013
if (sb == NULL) {
738
browse_callback, server);
739
if (!sb) {
1014
740
fprintf(stderr, "Failed to create service browser: %s\n",
1015
avahi_strerror(avahi_server_errno(mc.server)));
1016
exitcode = EXIT_FAILURE;
1017
goto end;
741
avahi_strerror(avahi_server_errno(server)));
742
returncode = EXIT_FAILURE;
743
goto exit;
1018
744
}
1019
745
1020
746
/* Run the main loop */
1021
747
1022
748
if (debug){
1023
fprintf(stderr, "Starting Avahi loop search\n");
749
fprintf(stderr, "Starting avahi loop search\n");
1024
750
}
1025
751
1026
avahi_simple_poll_loop(mc.simple_poll);
752
avahi_simple_poll_loop(simple_poll);
1027
753
1028
end:
754
exit:
1029
755
1030
756
if (debug){
1031
757
fprintf(stderr, "%s exiting\n", argv[0]);
1032
758
}
1033
759
1034
760
/* Cleanup things */
1035
if (sb != NULL)
761
if (sb)
1036
762
avahi_s_service_browser_free(sb);
1037
763
1038
if (mc.server != NULL)
1039
avahi_server_free(mc.server);
1040
1041
if (mc.simple_poll != NULL)
1042
avahi_simple_poll_free(mc.simple_poll);
1043
free(pubkeyfilename);
1044
free(seckeyfilename);
1045
1046
if (gnutls_initalized){
1047
gnutls_certificate_free_credentials(mc.cred);
1048
gnutls_global_deinit ();
1049
}
764
if (server)
765
avahi_server_free(server);
766
767
if (simple_poll)
768
avahi_simple_poll_free(simple_poll);
769
free(certfile);
770
free(certkey);
1050
771
1051
return exitcode;
772
return returncode;
1052
773
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0