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