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