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 353
- compare with another revision
- download diff
- download tarball
- view history from revision 353
- Committer: Teddy Hogeborn
- Date: 2009-08-27 23:12:09 UTC
- Revision ID: teddy@fukt.bsnet.se-20090827231209-ry9loqws0gr7ze4g
* plugins.d/mandos-client.c (quit_now): Move up declaration before
first use.
(resolve_callback, ): Check "quit_now" flag.
(main): Renamed "interface_taken_up" to "take_down_interface" for
clarity. Check existence of interface before taking it up.
Set "take_down_interface" and "tempdir_created" flags before
any action is taken, to make sure cleanup is never missed.
Check "quit_now" flag throughout.
first use.
(resolve_callback, ): Check "quit_now" flag.
(main): Renamed "interface_taken_up" to "take_down_interface" for
clarity. Check existence of interface before taking it up.
Set "take_down_interface" and "tempdir_created" flags before
any action is taken, to make sure cleanup is never missed.
Check "quit_now" flag throughout.
- files modified:
- INSTALL
added
removed
plugins.d/mandos-client.c
30
30
*/
31
31
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
33
34
#define _LARGEFILE_SOURCE
35
#endif
36
#ifndef _FILE_OFFSET_BITS
34
37
#define _FILE_OFFSET_BITS 64
38
#endif
35
39
36
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
41
38
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf(),
40
remove() */
43
stdout, ferror(), remove() */
41
44
#include <stdint.h> /* uint16_t, uint32_t */
42
45
#include <stddef.h> /* NULL, size_t, ssize_t */
43
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
44
srand() */
47
srand(), strtof() */
45
48
#include <stdbool.h> /* bool, false, true */
46
49
#include <string.h> /* memset(), strcmp(), strlen(),
47
50
strerror(), asprintf(), strcpy() */
56
59
#include <fcntl.h> /* open() */
57
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
58
61
*/
59
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
strtoimax() */
60
64
#include <assert.h> /* assert() */
61
65
#include <errno.h> /* perror(), errno */
62
66
#include <time.h> /* nanosleep(), time() */
75
79
argp_state, struct argp,
76
80
argp_parse(), ARGP_KEY_ARG,
77
81
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
82
#include <signal.h> /* sigemptyset(), sigaddset(),
83
sigaction(), SIGTERM, sigaction,
84
sig_atomic_t */
85
78
86
#ifdef __linux__
79
87
#include <sys/klog.h> /* klogctl() */
80
#endif
88
#endif /* __linux__ */
81
89
82
90
/* Avahi */
83
91
/* All Avahi types, constants and functions
129
137
gpgme_ctx_t ctx;
130
138
} mandos_context;
131
139
140
/* global context so signal handler can reach it*/
141
mandos_context mc = { .simple_poll = NULL, .server = NULL,
142
.dh_bits = 1024, .priority = "SECURE256"
143
":!CTYPE-X.509:+CTYPE-OPENPGP" };
144
132
145
/*
133
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
134
* "buffer_capacity" is how much is currently allocated,
146
* Make additional room in "buffer" for at least BUFFER_SIZE more
147
* bytes. "buffer_capacity" is how much is currently allocated,
135
148
* "buffer_length" is how much is already used.
136
149
*/
137
size_t adjustbuffer(char **buffer, size_t buffer_length,
150
size_t incbuffer(char **buffer, size_t buffer_length,
138
151
size_t buffer_capacity){
139
152
if(buffer_length + BUFFER_SIZE > buffer_capacity){
140
153
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
149
162
/*
150
163
* Initialize GPGME.
151
164
*/
152
static bool init_gpgme(mandos_context *mc, const char *seckey,
165
static bool init_gpgme(const char *seckey,
153
166
const char *pubkey, const char *tempdir){
154
167
int ret;
155
168
gpgme_error_t rc;
176
189
return false;
177
190
}
178
191
179
rc = gpgme_op_import(mc->ctx, pgp_data);
192
rc = gpgme_op_import(mc.ctx, pgp_data);
180
193
if(rc != GPG_ERR_NO_ERROR){
181
194
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
182
195
gpgme_strsource(rc), gpgme_strerror(rc));
192
205
}
193
206
194
207
if(debug){
195
fprintf(stderr, "Initialize gpgme\n");
208
fprintf(stderr, "Initializing GPGME\n");
196
209
}
197
210
198
211
/* Init GPGME */
225
238
}
226
239
227
240
/* Create new GPGME "context" */
228
rc = gpgme_new(&(mc->ctx));
241
rc = gpgme_new(&(mc.ctx));
229
242
if(rc != GPG_ERR_NO_ERROR){
230
243
fprintf(stderr, "bad gpgme_new: %s: %s\n",
231
244
gpgme_strsource(rc), gpgme_strerror(rc));
243
256
* Decrypt OpenPGP data.
244
257
* Returns -1 on error
245
258
*/
246
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
247
const char *cryptotext,
259
static ssize_t pgp_packet_decrypt(const char *cryptotext,
248
260
size_t crypto_size,
249
261
char **plaintext){
250
262
gpgme_data_t dh_crypto, dh_plain;
277
289
278
290
/* Decrypt data from the cryptotext data buffer to the plaintext
279
291
data buffer */
280
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
292
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
281
293
if(rc != GPG_ERR_NO_ERROR){
282
294
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
283
295
gpgme_strsource(rc), gpgme_strerror(rc));
284
296
plaintext_length = -1;
285
297
if(debug){
286
298
gpgme_decrypt_result_t result;
287
result = gpgme_op_decrypt_result(mc->ctx);
299
result = gpgme_op_decrypt_result(mc.ctx);
288
300
if(result == NULL){
289
301
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
290
302
} else {
297
309
}
298
310
gpgme_recipient_t recipient;
299
311
recipient = result->recipients;
300
if(recipient){
301
while(recipient != NULL){
302
fprintf(stderr, "Public key algorithm: %s\n",
303
gpgme_pubkey_algo_name(recipient->pubkey_algo));
304
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
305
fprintf(stderr, "Secret key available: %s\n",
306
recipient->status == GPG_ERR_NO_SECKEY
307
? "No" : "Yes");
308
recipient = recipient->next;
309
}
312
while(recipient != NULL){
313
fprintf(stderr, "Public key algorithm: %s\n",
314
gpgme_pubkey_algo_name(recipient->pubkey_algo));
315
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
316
fprintf(stderr, "Secret key available: %s\n",
317
recipient->status == GPG_ERR_NO_SECKEY
318
? "No" : "Yes");
319
recipient = recipient->next;
310
320
}
311
321
}
312
322
}
326
336
327
337
*plaintext = NULL;
328
338
while(true){
329
plaintext_capacity = adjustbuffer(plaintext,
339
plaintext_capacity = incbuffer(plaintext,
330
340
(size_t)plaintext_length,
331
341
plaintext_capacity);
332
342
if(plaintext_capacity == 0){
333
perror("adjustbuffer");
343
perror("incbuffer");
334
344
plaintext_length = -1;
335
345
goto decrypt_end;
336
346
}
382
392
fprintf(stderr, "GnuTLS: %s", string);
383
393
}
384
394
385
static int init_gnutls_global(mandos_context *mc,
386
const char *pubkeyfilename,
395
static int init_gnutls_global(const char *pubkeyfilename,
387
396
const char *seckeyfilename){
388
397
int ret;
389
398
407
416
}
408
417
409
418
/* OpenPGP credentials */
410
gnutls_certificate_allocate_credentials(&mc->cred);
419
gnutls_certificate_allocate_credentials(&mc.cred);
411
420
if(ret != GNUTLS_E_SUCCESS){
412
421
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
413
422
from
425
434
}
426
435
427
436
ret = gnutls_certificate_set_openpgp_key_file
428
(mc->cred, pubkeyfilename, seckeyfilename,
437
(mc.cred, pubkeyfilename, seckeyfilename,
429
438
GNUTLS_OPENPGP_FMT_BASE64);
430
439
if(ret != GNUTLS_E_SUCCESS){
431
440
fprintf(stderr,
437
446
}
438
447
439
448
/* GnuTLS server initialization */
440
ret = gnutls_dh_params_init(&mc->dh_params);
449
ret = gnutls_dh_params_init(&mc.dh_params);
441
450
if(ret != GNUTLS_E_SUCCESS){
442
451
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
443
452
" %s\n", safer_gnutls_strerror(ret));
444
453
goto globalfail;
445
454
}
446
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
455
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
447
456
if(ret != GNUTLS_E_SUCCESS){
448
457
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
449
458
safer_gnutls_strerror(ret));
450
459
goto globalfail;
451
460
}
452
461
453
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
462
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
454
463
455
464
return 0;
456
465
457
466
globalfail:
458
467
459
gnutls_certificate_free_credentials(mc->cred);
468
gnutls_certificate_free_credentials(mc.cred);
460
469
gnutls_global_deinit();
461
gnutls_dh_params_deinit(mc->dh_params);
470
gnutls_dh_params_deinit(mc.dh_params);
462
471
return -1;
463
472
}
464
473
465
static int init_gnutls_session(mandos_context *mc,
466
gnutls_session_t *session){
474
static int init_gnutls_session(gnutls_session_t *session){
467
475
int ret;
468
476
/* GnuTLS session creation */
469
477
ret = gnutls_init(session, GNUTLS_SERVER);
474
482
475
483
{
476
484
const char *err;
477
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
485
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
478
486
if(ret != GNUTLS_E_SUCCESS){
479
487
fprintf(stderr, "Syntax error at: %s\n", err);
480
488
fprintf(stderr, "GnuTLS error: %s\n",
485
493
}
486
494
487
495
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
488
mc->cred);
496
mc.cred);
489
497
if(ret != GNUTLS_E_SUCCESS){
490
498
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
491
499
safer_gnutls_strerror(ret));
497
505
gnutls_certificate_server_set_request(*session,
498
506
GNUTLS_CERT_IGNORE);
499
507
500
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
508
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
501
509
502
510
return 0;
503
511
}
509
517
/* Called when a Mandos server is found */
510
518
static int start_mandos_communication(const char *ip, uint16_t port,
511
519
AvahiIfIndex if_index,
512
mandos_context *mc, int af){
520
int af){
513
521
int ret, tcp_sd;
514
522
ssize_t sret;
515
523
union {
538
546
return -1;
539
547
}
540
548
541
ret = init_gnutls_session(mc, &session);
549
ret = init_gnutls_session(&session);
542
550
if(ret != 0){
543
551
return -1;
544
552
}
556
564
557
565
memset(&to, 0, sizeof(to));
558
566
if(af == AF_INET6){
559
to.in6.sin6_family = (uint16_t)af;
567
to.in6.sin6_family = (sa_family_t)af;
560
568
ret = inet_pton(af, ip, &to.in6.sin6_addr);
561
569
} else { /* IPv4 */
562
570
to.in.sin_family = (sa_family_t)af;
685
693
}
686
694
687
695
while(true){
688
buffer_capacity = adjustbuffer(&buffer, buffer_length,
696
buffer_capacity = incbuffer(&buffer, buffer_length,
689
697
buffer_capacity);
690
698
if(buffer_capacity == 0){
691
perror("adjustbuffer");
699
perror("incbuffer");
692
700
retval = -1;
693
701
goto mandos_end;
694
702
}
733
741
gnutls_bye(session, GNUTLS_SHUT_RDWR);
734
742
735
743
if(buffer_length > 0){
736
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
744
decrypted_buffer_size = pgp_packet_decrypt(buffer,
737
745
buffer_length,
738
746
&decrypted_buffer);
739
747
if(decrypted_buffer_size >= 0){
772
780
return retval;
773
781
}
774
782
783
sig_atomic_t quit_now = 0;
784
775
785
static void resolve_callback(AvahiSServiceResolver *r,
776
786
AvahiIfIndex interface,
777
787
AvahiProtocol proto,
785
795
AVAHI_GCC_UNUSED AvahiStringList *txt,
786
796
AVAHI_GCC_UNUSED AvahiLookupResultFlags
787
797
flags,
788
void* userdata){
789
mandos_context *mc = userdata;
798
AVAHI_GCC_UNUSED void* userdata){
790
799
assert(r);
791
800
792
801
/* Called whenever a service has been resolved successfully or
793
802
timed out */
794
803
804
if(quit_now){
805
return;
806
}
807
795
808
switch(event){
796
809
default:
797
810
case AVAHI_RESOLVER_FAILURE:
798
811
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
799
812
" of type '%s' in domain '%s': %s\n", name, type, domain,
800
avahi_strerror(avahi_server_errno(mc->server)));
813
avahi_strerror(avahi_server_errno(mc.server)));
801
814
break;
802
815
803
816
case AVAHI_RESOLVER_FOUND:
809
822
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
810
823
ip, (intmax_t)interface, port);
811
824
}
812
int ret = start_mandos_communication(ip, port, interface, mc,
825
int ret = start_mandos_communication(ip, port, interface,
813
826
avahi_proto_to_af(proto));
814
827
if(ret == 0){
815
avahi_simple_poll_quit(mc->simple_poll);
828
avahi_simple_poll_quit(mc.simple_poll);
816
829
}
817
830
}
818
831
}
828
841
const char *domain,
829
842
AVAHI_GCC_UNUSED AvahiLookupResultFlags
830
843
flags,
831
void* userdata){
832
mandos_context *mc = userdata;
844
AVAHI_GCC_UNUSED void* userdata){
833
845
assert(b);
834
846
835
847
/* Called whenever a new services becomes available on the LAN or
840
852
case AVAHI_BROWSER_FAILURE:
841
853
842
854
fprintf(stderr, "(Avahi browser) %s\n",
843
avahi_strerror(avahi_server_errno(mc->server)));
844
avahi_simple_poll_quit(mc->simple_poll);
855
avahi_strerror(avahi_server_errno(mc.server)));
856
avahi_simple_poll_quit(mc.simple_poll);
845
857
return;
846
858
847
859
case AVAHI_BROWSER_NEW:
850
862
the callback function is called the Avahi server will free the
851
863
resolver for us. */
852
864
853
if(!(avahi_s_service_resolver_new(mc->server, interface,
854
protocol, name, type, domain,
855
AVAHI_PROTO_INET6, 0,
856
resolve_callback, mc)))
865
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
866
name, type, domain, protocol, 0,
867
resolve_callback, NULL) == NULL)
857
868
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
858
name, avahi_strerror(avahi_server_errno(mc->server)));
869
name, avahi_strerror(avahi_server_errno(mc.server)));
859
870
break;
860
871
861
872
case AVAHI_BROWSER_REMOVE:
870
881
}
871
882
}
872
883
884
/* stop main loop after sigterm has been called */
885
static void handle_sigterm(__attribute__((unused)) int sig){
886
if(quit_now){
887
return;
888
}
889
quit_now = 1;
890
int old_errno = errno;
891
if(mc.simple_poll != NULL){
892
avahi_simple_poll_quit(mc.simple_poll);
893
}
894
errno = old_errno;
895
}
896
873
897
int main(int argc, char *argv[]){
874
898
AvahiSServiceBrowser *sb = NULL;
875
899
int error;
876
900
int ret;
877
901
intmax_t tmpmax;
878
int numchars;
902
char *tmp;
879
903
int exitcode = EXIT_SUCCESS;
880
904
const char *interface = "eth0";
881
905
struct ifreq network;
882
int sd;
906
int sd = -1;
907
bool take_down_interface = false;
883
908
uid_t uid;
884
909
gid_t gid;
885
910
char *connect_to = NULL;
889
914
const char *seckey = PATHDIR "/" SECKEY;
890
915
const char *pubkey = PATHDIR "/" PUBKEY;
891
916
892
mandos_context mc = { .simple_poll = NULL, .server = NULL,
893
.dh_bits = 1024, .priority = "SECURE256"
894
":!CTYPE-X.509:+CTYPE-OPENPGP" };
895
917
bool gnutls_initialized = false;
896
918
bool gpgme_initialized = false;
897
double delay = 2.5;
919
float delay = 2.5f;
920
921
struct sigaction old_sigterm_action;
922
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
898
923
899
924
{
900
925
struct argp_option options[] = {
952
977
pubkey = arg;
953
978
break;
954
979
case 129: /* --dh-bits */
955
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
956
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
957
or arg[numchars] != '\0'){
980
errno = 0;
981
tmpmax = strtoimax(arg, &tmp, 10);
982
if(errno != 0 or tmp == arg or *tmp != '\0'
983
or tmpmax != (typeof(mc.dh_bits))tmpmax){
958
984
fprintf(stderr, "Bad number of DH bits\n");
959
985
exit(EXIT_FAILURE);
960
986
}
964
990
mc.priority = arg;
965
991
break;
966
992
case 131: /* --delay */
967
ret = sscanf(arg, "%lf%n", &delay, &numchars);
968
if(ret < 1 or arg[numchars] != '\0'){
993
errno = 0;
994
delay = strtof(arg, &tmp);
995
if(errno != 0 or tmp == arg or *tmp != '\0'){
969
996
fprintf(stderr, "Bad delay\n");
970
997
exit(EXIT_FAILURE);
971
998
}
992
1019
}
993
1020
}
994
1021
1022
if(not debug){
1023
avahi_set_log_function(empty_log);
1024
}
1025
1026
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1027
from the signal handler */
1028
/* Initialize the pseudo-RNG for Avahi */
1029
srand((unsigned int) time(NULL));
1030
mc.simple_poll = avahi_simple_poll_new();
1031
if(mc.simple_poll == NULL){
1032
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1033
exitcode = EXIT_FAILURE;
1034
goto end;
1035
}
1036
1037
sigemptyset(&sigterm_action.sa_mask);
1038
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1039
if(ret == -1){
1040
perror("sigaddset");
1041
exitcode = EXIT_FAILURE;
1042
goto end;
1043
}
1044
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1045
if(ret == -1){
1046
perror("sigaddset");
1047
exitcode = EXIT_FAILURE;
1048
goto end;
1049
}
1050
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1051
if(ret == -1){
1052
perror("sigaddset");
1053
exitcode = EXIT_FAILURE;
1054
goto end;
1055
}
1056
ret = sigaction(SIGTERM, &sigterm_action, &old_sigterm_action);
1057
if(ret == -1){
1058
perror("sigaction");
1059
exitcode = EXIT_FAILURE;
1060
goto end;
1061
}
1062
995
1063
/* If the interface is down, bring it up */
996
1064
if(interface[0] != '\0'){
1065
if_index = (AvahiIfIndex) if_nametoindex(interface);
1066
if(if_index == 0){
1067
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1068
exitcode = EXIT_FAILURE;
1069
goto end;
1070
}
1071
1072
if(quit_now){
1073
goto end;
1074
}
1075
997
1076
#ifdef __linux__
998
1077
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
999
1078
messages to mess up the prompt */
1003
1082
restore_loglevel = false;
1004
1083
perror("klogctl");
1005
1084
}
1006
#endif
1085
#endif /* __linux__ */
1007
1086
1008
1087
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1009
1088
if(sd < 0){
1016
1095
perror("klogctl");
1017
1096
}
1018
1097
}
1019
#endif
1098
#endif /* __linux__ */
1020
1099
goto end;
1021
1100
}
1022
1101
strcpy(network.ifr_name, interface);
1030
1109
perror("klogctl");
1031
1110
}
1032
1111
}
1033
#endif
1112
#endif /* __linux__ */
1034
1113
exitcode = EXIT_FAILURE;
1035
1114
goto end;
1036
1115
}
1037
1116
if((network.ifr_flags & IFF_UP) == 0){
1038
1117
network.ifr_flags |= IFF_UP;
1118
take_down_interface = true;
1039
1119
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1040
1120
if(ret == -1){
1121
take_down_interface = false;
1041
1122
perror("ioctl SIOCSIFFLAGS");
1042
1123
exitcode = EXIT_FAILURE;
1043
1124
#ifdef __linux__
1047
1128
perror("klogctl");
1048
1129
}
1049
1130
}
1050
#endif
1131
#endif /* __linux__ */
1051
1132
goto end;
1052
1133
}
1053
1134
}
1065
1146
perror("nanosleep");
1066
1147
}
1067
1148
}
1068
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1069
if(ret == -1){
1070
perror("close");
1149
if(not take_down_interface){
1150
/* We won't need the socket anymore */
1151
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1152
if(ret == -1){
1153
perror("close");
1154
}
1071
1155
}
1072
1156
#ifdef __linux__
1073
1157
if(restore_loglevel){
1077
1161
perror("klogctl");
1078
1162
}
1079
1163
}
1080
#endif
1164
#endif /* __linux__ */
1165
}
1166
1167
if(quit_now){
1168
goto end;
1081
1169
}
1082
1170
1083
1171
uid = getuid();
1094
1182
perror("setuid");
1095
1183
}
1096
1184
1097
ret = init_gnutls_global(&mc, pubkey, seckey);
1185
if(quit_now){
1186
goto end;
1187
}
1188
1189
ret = init_gnutls_global(pubkey, seckey);
1098
1190
if(ret == -1){
1099
1191
fprintf(stderr, "init_gnutls_global failed\n");
1100
1192
exitcode = EXIT_FAILURE;
1103
1195
gnutls_initialized = true;
1104
1196
}
1105
1197
1198
if(quit_now){
1199
goto end;
1200
}
1201
1202
tempdir_created = true;
1106
1203
if(mkdtemp(tempdir) == NULL){
1204
tempdir_created = false;
1107
1205
perror("mkdtemp");
1108
1206
goto end;
1109
1207
}
1110
tempdir_created = true;
1111
1112
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
1208
1209
if(quit_now){
1210
goto end;
1211
}
1212
1213
if(not init_gpgme(pubkey, seckey, tempdir)){
1113
1214
fprintf(stderr, "init_gpgme failed\n");
1114
1215
exitcode = EXIT_FAILURE;
1115
1216
goto end;
1117
1218
gpgme_initialized = true;
1118
1219
}
1119
1220
1120
if(interface[0] != '\0'){
1121
if_index = (AvahiIfIndex) if_nametoindex(interface);
1122
if(if_index == 0){
1123
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1124
exitcode = EXIT_FAILURE;
1125
goto end;
1126
}
1221
if(quit_now){
1222
goto end;
1127
1223
}
1128
1224
1129
1225
if(connect_to != NULL){
1135
1231
exitcode = EXIT_FAILURE;
1136
1232
goto end;
1137
1233
}
1234
1235
if(quit_now){
1236
goto end;
1237
}
1238
1138
1239
uint16_t port;
1139
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1140
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1141
or address[numchars+1] != '\0'){
1240
errno = 0;
1241
tmpmax = strtoimax(address+1, &tmp, 10);
1242
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1243
or tmpmax != (uint16_t)tmpmax){
1142
1244
fprintf(stderr, "Bad port number\n");
1143
1245
exitcode = EXIT_FAILURE;
1144
1246
goto end;
1145
1247
}
1248
1249
if(quit_now){
1250
goto end;
1251
}
1252
1146
1253
port = (uint16_t)tmpmax;
1147
1254
*address = '\0';
1148
1255
address = connect_to;
1153
1260
} else {
1154
1261
af = AF_INET;
1155
1262
}
1156
ret = start_mandos_communication(address, port, if_index, &mc,
1157
af);
1263
1264
if(quit_now){
1265
goto end;
1266
}
1267
1268
ret = start_mandos_communication(address, port, if_index, af);
1158
1269
if(ret < 0){
1159
1270
exitcode = EXIT_FAILURE;
1160
1271
} else {
1163
1274
goto end;
1164
1275
}
1165
1276
1166
if(not debug){
1167
avahi_set_log_function(empty_log);
1168
}
1169
1170
/* Initialize the pseudo-RNG for Avahi */
1171
srand((unsigned int) time(NULL));
1172
1173
/* Allocate main Avahi loop object */
1174
mc.simple_poll = avahi_simple_poll_new();
1175
if(mc.simple_poll == NULL){
1176
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1177
exitcode = EXIT_FAILURE;
1277
if(quit_now){
1178
1278
goto end;
1179
1279
}
1180
1280
1204
1304
goto end;
1205
1305
}
1206
1306
1307
if(quit_now){
1308
goto end;
1309
}
1310
1207
1311
/* Create the Avahi service browser */
1208
1312
sb = avahi_s_service_browser_new(mc.server, if_index,
1209
AVAHI_PROTO_INET6, "_mandos._tcp",
1210
NULL, 0, browse_callback, &mc);
1313
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1314
NULL, 0, browse_callback, NULL);
1211
1315
if(sb == NULL){
1212
1316
fprintf(stderr, "Failed to create service browser: %s\n",
1213
1317
avahi_strerror(avahi_server_errno(mc.server)));
1215
1319
goto end;
1216
1320
}
1217
1321
1322
if(quit_now){
1323
goto end;
1324
}
1325
1218
1326
/* Run the main loop */
1219
1327
1220
1328
if(debug){
1249
1357
gpgme_release(mc.ctx);
1250
1358
}
1251
1359
1360
/* Take down the network interface */
1361
if(take_down_interface){
1362
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1363
if(ret == -1){
1364
perror("ioctl SIOCGIFFLAGS");
1365
} else if(network.ifr_flags & IFF_UP) {
1366
network.ifr_flags &= ~IFF_UP; /* clear flag */
1367
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1368
if(ret == -1){
1369
perror("ioctl SIOCSIFFLAGS");
1370
}
1371
}
1372
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1373
if(ret == -1){
1374
perror("close");
1375
}
1376
}
1377
1252
1378
/* Removes the temp directory used by GPGME */
1253
1379
if(tempdir_created){
1254
1380
DIR *d;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0