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