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