35
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf(),
39
41
#include <stdint.h> /* uint16_t, uint32_t */
40
42
#include <stddef.h> /* NULL, size_t, ssize_t */
41
43
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
43
#include <stdbool.h> /* bool, true */
45
#include <stdbool.h> /* bool, false, true */
44
46
#include <string.h> /* memset(), strcmp(), strlen(),
45
47
strerror(), asprintf(), strcpy() */
46
#include <sys/ioctl.h> /* ioctl */
48
#include <sys/ioctl.h> /* ioctl */
47
49
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
48
50
sockaddr_in6, PF_INET6,
49
SOCK_STREAM, INET6_ADDRSTRLEN,
51
#include <inttypes.h> /* PRIu16 */
51
SOCK_STREAM, uid_t, gid_t, open(),
53
#include <sys/stat.h> /* open() */
52
54
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton(),
55
inet_pton(), connect() */
56
#include <fcntl.h> /* open() */
57
#include <dirent.h> /* opendir(), struct dirent, readdir()
59
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
55
60
#include <assert.h> /* assert() */
56
61
#include <errno.h> /* perror(), errno */
57
#include <time.h> /* time() */
62
#include <time.h> /* nanosleep(), time() */
58
63
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
59
64
SIOCSIFFLAGS, if_indextoname(),
60
65
if_nametoindex(), IF_NAMESIZE */
66
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
67
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
61
69
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
62
70
getuid(), getgid(), setuid(),
64
#include <netinet/in.h>
65
72
#include <arpa/inet.h> /* inet_pton(), htons */
66
#include <iso646.h> /* not, and */
73
#include <iso646.h> /* not, or, and */
67
74
#include <argp.h> /* struct argp_option, error_t, struct
68
75
argp_state, struct argp,
69
76
argp_parse(), ARGP_KEY_ARG,
70
77
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
78
#include <signal.h> /* sigemptyset(), sigaddset(),
79
sigaction(), SIGTERM, sigaction,
83
#include <sys/klog.h> /* klogctl() */
84
#endif /* __linux__ */
73
87
/* All Avahi types, constants and functions
135
* Decrypt OpenPGP data using keyrings in HOMEDIR.
136
* Returns -1 on error
138
static ssize_t pgp_packet_decrypt (const char *cryptotext,
141
const char *homedir){
142
gpgme_data_t dh_crypto, dh_plain;
161
static bool init_gpgme(const char *seckey,
162
const char *pubkey, const char *tempdir){
144
164
gpgme_error_t rc;
146
size_t plaintext_capacity = 0;
147
ssize_t plaintext_length = 0;
148
165
gpgme_engine_info_t engine_info;
151
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
169
* Helper function to insert pub and seckey to the engine keyring.
171
bool import_key(const char *filename){
173
gpgme_data_t pgp_data;
175
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
181
rc = gpgme_data_new_from_fd(&pgp_data, fd);
182
if(rc != GPG_ERR_NO_ERROR){
183
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
184
gpgme_strsource(rc), gpgme_strerror(rc));
188
rc = gpgme_op_import(mc.ctx, pgp_data);
189
if(rc != GPG_ERR_NO_ERROR){
190
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
191
gpgme_strsource(rc), gpgme_strerror(rc));
195
ret = (int)TEMP_FAILURE_RETRY(close(fd));
199
gpgme_data_release(pgp_data);
204
fprintf(stderr, "Initializing GPGME\n");
155
208
gpgme_check_version(NULL);
156
209
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
157
if (rc != GPG_ERR_NO_ERROR){
210
if(rc != GPG_ERR_NO_ERROR){
158
211
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
159
212
gpgme_strsource(rc), gpgme_strerror(rc));
163
/* Set GPGME home directory for the OpenPGP engine only */
164
rc = gpgme_get_engine_info (&engine_info);
165
if (rc != GPG_ERR_NO_ERROR){
216
/* Set GPGME home directory for the OpenPGP engine only */
217
rc = gpgme_get_engine_info(&engine_info);
218
if(rc != GPG_ERR_NO_ERROR){
166
219
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
167
220
gpgme_strsource(rc), gpgme_strerror(rc));
170
223
while(engine_info != NULL){
171
224
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
172
225
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
173
engine_info->file_name, homedir);
226
engine_info->file_name, tempdir);
176
229
engine_info = engine_info->next;
178
231
if(engine_info == NULL){
179
fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
232
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
236
/* Create new GPGME "context" */
237
rc = gpgme_new(&(mc.ctx));
238
if(rc != GPG_ERR_NO_ERROR){
239
fprintf(stderr, "bad gpgme_new: %s: %s\n",
240
gpgme_strsource(rc), gpgme_strerror(rc));
244
if(not import_key(pubkey) or not import_key(seckey)){
252
* Decrypt OpenPGP data.
253
* Returns -1 on error
255
static ssize_t pgp_packet_decrypt(const char *cryptotext,
258
gpgme_data_t dh_crypto, dh_plain;
261
size_t plaintext_capacity = 0;
262
ssize_t plaintext_length = 0;
265
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
183
268
/* Create new GPGME data buffer from memory cryptotext */
184
269
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
186
if (rc != GPG_ERR_NO_ERROR){
271
if(rc != GPG_ERR_NO_ERROR){
187
272
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
188
273
gpgme_strsource(rc), gpgme_strerror(rc));
341
416
/* OpenPGP credentials */
342
gnutls_certificate_allocate_credentials(&mc->cred);
343
if (ret != GNUTLS_E_SUCCESS){
344
fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
346
safer_gnutls_strerror(ret));
347
gnutls_global_deinit ();
417
gnutls_certificate_allocate_credentials(&mc.cred);
418
if(ret != GNUTLS_E_SUCCESS){
419
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
423
safer_gnutls_strerror(ret));
424
gnutls_global_deinit();
352
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
353
" and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
429
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
430
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
357
434
ret = gnutls_certificate_set_openpgp_key_file
358
(mc->cred, pubkeyfilename, seckeyfilename,
435
(mc.cred, pubkeyfilename, seckeyfilename,
359
436
GNUTLS_OPENPGP_FMT_BASE64);
360
if (ret != GNUTLS_E_SUCCESS) {
437
if(ret != GNUTLS_E_SUCCESS){
362
439
"Error[%d] while reading the OpenPGP key pair ('%s',"
363
440
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
364
fprintf(stdout, "The GnuTLS error is: %s\n",
441
fprintf(stderr, "The GnuTLS error is: %s\n",
365
442
safer_gnutls_strerror(ret));
369
446
/* GnuTLS server initialization */
370
ret = gnutls_dh_params_init(&mc->dh_params);
371
if (ret != GNUTLS_E_SUCCESS) {
372
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
373
" %s\n", safer_gnutls_strerror(ret));
376
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
377
if (ret != GNUTLS_E_SUCCESS) {
378
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
379
safer_gnutls_strerror(ret));
383
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
447
ret = gnutls_dh_params_init(&mc.dh_params);
448
if(ret != GNUTLS_E_SUCCESS){
449
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
450
" %s\n", safer_gnutls_strerror(ret));
453
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
454
if(ret != GNUTLS_E_SUCCESS){
455
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
456
safer_gnutls_strerror(ret));
460
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
389
gnutls_certificate_free_credentials(mc->cred);
466
gnutls_certificate_free_credentials(mc.cred);
390
467
gnutls_global_deinit();
468
gnutls_dh_params_deinit(mc.dh_params);
395
static int init_gnutls_session(mandos_context *mc,
396
gnutls_session_t *session){
472
static int init_gnutls_session(gnutls_session_t *session){
398
474
/* GnuTLS session creation */
399
475
ret = gnutls_init(session, GNUTLS_SERVER);
400
if (ret != GNUTLS_E_SUCCESS){
476
if(ret != GNUTLS_E_SUCCESS){
401
477
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
402
478
safer_gnutls_strerror(ret));
407
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
408
if (ret != GNUTLS_E_SUCCESS) {
483
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
484
if(ret != GNUTLS_E_SUCCESS){
409
485
fprintf(stderr, "Syntax error at: %s\n", err);
410
486
fprintf(stderr, "GnuTLS error: %s\n",
411
487
safer_gnutls_strerror(ret));
412
gnutls_deinit (*session);
488
gnutls_deinit(*session);
417
493
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
419
if (ret != GNUTLS_E_SUCCESS) {
495
if(ret != GNUTLS_E_SUCCESS){
420
496
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
421
497
safer_gnutls_strerror(ret));
422
gnutls_deinit (*session);
498
gnutls_deinit(*session);
426
502
/* ignore client certificate if any. */
427
gnutls_certificate_server_set_request (*session,
503
gnutls_certificate_server_set_request(*session,
430
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
506
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
747
/* Combines file name and path and returns the malloced new
748
string. some sane checks could/should be added */
749
static char *combinepath(const char *first, const char *second){
751
int ret = asprintf(&tmp, "%s/%s", first, second);
877
sig_atomic_t quit_now = 0;
879
/* stop main loop after sigterm has been called */
880
static void handle_sigterm(__attribute__((unused)) int sig){
885
int old_errno = errno;
886
if(mc.simple_poll != NULL){
887
avahi_simple_poll_quit(mc.simple_poll);
759
892
int main(int argc, char *argv[]){
760
AvahiSServiceBrowser *sb = NULL;
763
int exitcode = EXIT_SUCCESS;
764
const char *interface = "eth0";
765
struct ifreq network;
769
char *connect_to = NULL;
770
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
771
char *pubkeyfilename = NULL;
772
char *seckeyfilename = NULL;
773
const char *pubkeyname = "pubkey.txt";
774
const char *seckeyname = "seckey.txt";
775
mandos_context mc = { .simple_poll = NULL, .server = NULL,
776
.dh_bits = 1024, .priority = "SECURE256"};
777
bool gnutls_initalized = false;
780
struct argp_option options[] = {
781
{ .name = "debug", .key = 128,
782
.doc = "Debug mode", .group = 3 },
783
{ .name = "connect", .key = 'c',
785
.doc = "Connect directly to a sepcified mandos server",
787
{ .name = "interface", .key = 'i',
789
.doc = "Interface that Avahi will conntect through",
791
{ .name = "keydir", .key = 'd',
793
.doc = "Directory where the openpgp keyring is",
795
{ .name = "seckey", .key = 's',
797
.doc = "Secret openpgp key for gnutls authentication",
799
{ .name = "pubkey", .key = 'p',
801
.doc = "Public openpgp key for gnutls authentication",
803
{ .name = "dh-bits", .key = 129,
805
.doc = "dh-bits to use in gnutls communication",
807
{ .name = "priority", .key = 130,
809
.doc = "GNUTLS priority", .group = 1 },
893
AvahiSServiceBrowser *sb = NULL;
898
int exitcode = EXIT_SUCCESS;
899
const char *interface = "eth0";
900
struct ifreq network;
904
char *connect_to = NULL;
905
char tempdir[] = "/tmp/mandosXXXXXX";
906
bool tempdir_created = false;
907
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
908
const char *seckey = PATHDIR "/" SECKEY;
909
const char *pubkey = PATHDIR "/" PUBKEY;
911
/* Initialize Mandos context */
912
mc = (mandos_context){ .simple_poll = NULL, .server = NULL,
913
.dh_bits = 1024, .priority = "SECURE256"
914
":!CTYPE-X.509:+CTYPE-OPENPGP" };
915
bool gnutls_initialized = false;
916
bool gpgme_initialized = false;
814
error_t parse_opt (int key, char *arg,
815
struct argp_state *state) {
816
/* Get the INPUT argument from `argp_parse', which we know is
817
a pointer to our plugin list pointer. */
839
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
919
struct sigaction old_sigterm_action;
920
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
923
struct argp_option options[] = {
924
{ .name = "debug", .key = 128,
925
.doc = "Debug mode", .group = 3 },
926
{ .name = "connect", .key = 'c',
927
.arg = "ADDRESS:PORT",
928
.doc = "Connect directly to a specific Mandos server",
930
{ .name = "interface", .key = 'i',
932
.doc = "Network interface that will be used to search for"
935
{ .name = "seckey", .key = 's',
937
.doc = "OpenPGP secret key file base name",
939
{ .name = "pubkey", .key = 'p',
941
.doc = "OpenPGP public key file base name",
943
{ .name = "dh-bits", .key = 129,
945
.doc = "Bit length of the prime number used in the"
946
" Diffie-Hellman key exchange",
948
{ .name = "priority", .key = 130,
950
.doc = "GnuTLS priority string for the TLS handshake",
952
{ .name = "delay", .key = 131,
954
.doc = "Maximum delay to wait for interface startup",
959
error_t parse_opt(int key, char *arg,
960
struct argp_state *state){
962
case 128: /* --debug */
965
case 'c': /* --connect */
968
case 'i': /* --interface */
971
case 's': /* --seckey */
974
case 'p': /* --pubkey */
977
case 129: /* --dh-bits */
978
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
979
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
980
or arg[numchars] != '\0'){
981
fprintf(stderr, "Bad number of DH bits\n");
984
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
986
case 130: /* --priority */
989
case 131: /* --delay */
990
ret = sscanf(arg, "%lf%n", &delay, &numchars);
991
if(ret < 1 or arg[numchars] != '\0'){
992
fprintf(stderr, "Bad delay\n");
1001
return ARGP_ERR_UNKNOWN;
1006
struct argp argp = { .options = options, .parser = parse_opt,
1008
.doc = "Mandos client -- Get and decrypt"
1009
" passwords from a Mandos server" };
1010
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
1011
if(ret == ARGP_ERR_UNKNOWN){
1012
fprintf(stderr, "Unknown error while parsing arguments\n");
1013
exitcode = EXIT_FAILURE;
1019
avahi_set_log_function(empty_log);
1022
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1023
from the signal handler */
1024
/* Initialize the pseudo-RNG for Avahi */
1025
srand((unsigned int) time(NULL));
1026
mc.simple_poll = avahi_simple_poll_new();
1027
if(mc.simple_poll == NULL){
1028
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1029
exitcode = EXIT_FAILURE;
1033
sigemptyset(&sigterm_action.sa_mask);
1034
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1036
perror("sigaddset");
1037
exitcode = EXIT_FAILURE;
1040
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1042
perror("sigaddset");
1043
exitcode = EXIT_FAILURE;
1046
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1048
perror("sigaddset");
1049
exitcode = EXIT_FAILURE;
1052
ret = sigaction(SIGTERM, &sigterm_action, &old_sigterm_action);
1054
perror("sigaction");
1055
exitcode = EXIT_FAILURE;
1059
/* If the interface is down, bring it up */
1060
if(interface[0] != '\0'){
1062
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1063
messages to mess up the prompt */
1064
ret = klogctl(8, NULL, 5);
1065
bool restore_loglevel = true;
1067
restore_loglevel = false;
1070
#endif /* __linux__ */
1072
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1075
exitcode = EXIT_FAILURE;
1077
if(restore_loglevel){
1078
ret = klogctl(7, NULL, 0);
1083
#endif /* __linux__ */
1086
strcpy(network.ifr_name, interface);
1087
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1089
perror("ioctl SIOCGIFFLAGS");
1091
if(restore_loglevel){
1092
ret = klogctl(7, NULL, 0);
1097
#endif /* __linux__ */
1098
exitcode = EXIT_FAILURE;
1101
if((network.ifr_flags & IFF_UP) == 0){
1102
network.ifr_flags |= IFF_UP;
1103
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1105
perror("ioctl SIOCSIFFLAGS");
1106
exitcode = EXIT_FAILURE;
1108
if(restore_loglevel){
1109
ret = klogctl(7, NULL, 0);
853
return ARGP_ERR_UNKNOWN;
858
struct argp argp = { .options = options, .parser = parse_opt,
860
.doc = "Mandos client -- Get and decrypt"
861
" passwords from mandos server" };
862
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
863
if (ret == ARGP_ERR_UNKNOWN){
864
fprintf(stderr, "Unknown error while parsing arguments\n");
865
exitcode = EXIT_FAILURE;
870
pubkeyfilename = combinepath(keydir, pubkeyname);
871
if (pubkeyfilename == NULL){
872
perror("combinepath");
873
exitcode = EXIT_FAILURE;
877
seckeyfilename = combinepath(keydir, seckeyname);
878
if (seckeyfilename == NULL){
879
perror("combinepath");
880
exitcode = EXIT_FAILURE;
884
ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
886
fprintf(stderr, "init_gnutls_global failed\n");
887
exitcode = EXIT_FAILURE;
890
gnutls_initalized = true;
893
/* If the interface is down, bring it up */
895
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
898
exitcode = EXIT_FAILURE;
901
strcpy(network.ifr_name, interface);
1114
#endif /* __linux__ */
1118
/* sleep checking until interface is running */
1119
for(int i=0; i < delay * 4; i++){
902
1120
ret = ioctl(sd, SIOCGIFFLAGS, &network);
904
1122
perror("ioctl SIOCGIFFLAGS");
905
exitcode = EXIT_FAILURE;
908
if((network.ifr_flags & IFF_UP) == 0){
909
network.ifr_flags |= IFF_UP;
910
ret = ioctl(sd, SIOCSIFFLAGS, &network);
912
perror("ioctl SIOCSIFFLAGS");
913
exitcode = EXIT_FAILURE;
1123
} else if(network.ifr_flags & IFF_RUNNING){
1126
struct timespec sleeptime = { .tv_nsec = 250000000 };
1127
ret = nanosleep(&sleeptime, NULL);
1128
if(ret == -1 and errno != EINTR){
1129
perror("nanosleep");
1132
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1137
if(restore_loglevel){
1138
/* Restores kernel loglevel to default */
1139
ret = klogctl(7, NULL, 0);
1144
#endif /* __linux__ */
1161
ret = init_gnutls_global(pubkey, seckey);
1163
fprintf(stderr, "init_gnutls_global failed\n");
1164
exitcode = EXIT_FAILURE;
1167
gnutls_initialized = true;
1170
if(mkdtemp(tempdir) == NULL){
1174
tempdir_created = true;
1176
if(not init_gpgme(pubkey, seckey, tempdir)){
1177
fprintf(stderr, "init_gpgme failed\n");
1178
exitcode = EXIT_FAILURE;
1181
gpgme_initialized = true;
1184
if(interface[0] != '\0'){
933
1185
if_index = (AvahiIfIndex) if_nametoindex(interface);
934
1186
if(if_index == 0){
935
1187
fprintf(stderr, "No such interface: \"%s\"\n", interface);
939
if(connect_to != NULL){
940
/* Connect directly, do not use Zeroconf */
941
/* (Mainly meant for debugging) */
942
char *address = strrchr(connect_to, ':');
944
fprintf(stderr, "No colon in address\n");
945
exitcode = EXIT_FAILURE;
949
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
951
perror("Bad port number");
952
exitcode = EXIT_FAILURE;
956
address = connect_to;
957
ret = start_mandos_communication(address, port, if_index, &mc);
959
exitcode = EXIT_FAILURE;
961
exitcode = EXIT_SUCCESS;
967
avahi_set_log_function(empty_log);
970
/* Initialize the pseudo-RNG for Avahi */
971
srand((unsigned int) time(NULL));
973
/* Allocate main Avahi loop object */
974
mc.simple_poll = avahi_simple_poll_new();
975
if (mc.simple_poll == NULL) {
976
fprintf(stderr, "Avahi: Failed to create simple poll"
978
exitcode = EXIT_FAILURE;
983
AvahiServerConfig config;
984
/* Do not publish any local Zeroconf records */
985
avahi_server_config_init(&config);
986
config.publish_hinfo = 0;
987
config.publish_addresses = 0;
988
config.publish_workstation = 0;
989
config.publish_domain = 0;
991
/* Allocate a new server */
992
mc.server = avahi_server_new(avahi_simple_poll_get
993
(mc.simple_poll), &config, NULL,
996
/* Free the Avahi configuration data */
997
avahi_server_config_free(&config);
1000
/* Check if creating the Avahi server object succeeded */
1001
if (mc.server == NULL) {
1002
fprintf(stderr, "Failed to create Avahi server: %s\n",
1003
avahi_strerror(error));
1004
exitcode = EXIT_FAILURE;
1008
/* Create the Avahi service browser */
1009
sb = avahi_s_service_browser_new(mc.server, if_index,
1011
"_mandos._tcp", NULL, 0,
1012
browse_callback, &mc);
1014
fprintf(stderr, "Failed to create service browser: %s\n",
1015
avahi_strerror(avahi_server_errno(mc.server)));
1016
exitcode = EXIT_FAILURE;
1020
/* Run the main loop */
1023
fprintf(stderr, "Starting Avahi loop search\n");
1026
avahi_simple_poll_loop(mc.simple_poll);
1188
exitcode = EXIT_FAILURE;
1193
if(connect_to != NULL){
1194
/* Connect directly, do not use Zeroconf */
1195
/* (Mainly meant for debugging) */
1196
char *address = strrchr(connect_to, ':');
1197
if(address == NULL){
1198
fprintf(stderr, "No colon in address\n");
1199
exitcode = EXIT_FAILURE;
1203
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1204
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1205
or address[numchars+1] != '\0'){
1206
fprintf(stderr, "Bad port number\n");
1207
exitcode = EXIT_FAILURE;
1210
port = (uint16_t)tmpmax;
1212
address = connect_to;
1213
/* Colon in address indicates IPv6 */
1215
if(strchr(address, ':') != NULL){
1220
ret = start_mandos_communication(address, port, if_index, af);
1222
exitcode = EXIT_FAILURE;
1224
exitcode = EXIT_SUCCESS;
1230
AvahiServerConfig config;
1231
/* Do not publish any local Zeroconf records */
1232
avahi_server_config_init(&config);
1233
config.publish_hinfo = 0;
1234
config.publish_addresses = 0;
1235
config.publish_workstation = 0;
1236
config.publish_domain = 0;
1238
/* Allocate a new server */
1239
mc.server = avahi_server_new(avahi_simple_poll_get
1240
(mc.simple_poll), &config, NULL,
1243
/* Free the Avahi configuration data */
1244
avahi_server_config_free(&config);
1247
/* Check if creating the Avahi server object succeeded */
1248
if(mc.server == NULL){
1249
fprintf(stderr, "Failed to create Avahi server: %s\n",
1250
avahi_strerror(error));
1251
exitcode = EXIT_FAILURE;
1255
/* Create the Avahi service browser */
1256
sb = avahi_s_service_browser_new(mc.server, if_index,
1257
AVAHI_PROTO_INET6, "_mandos._tcp",
1258
NULL, 0, browse_callback, NULL);
1260
fprintf(stderr, "Failed to create service browser: %s\n",
1261
avahi_strerror(avahi_server_errno(mc.server)));
1262
exitcode = EXIT_FAILURE;
1266
/* Run the main loop */
1269
fprintf(stderr, "Starting Avahi loop search\n");
1272
avahi_simple_poll_loop(mc.simple_poll);
1031
fprintf(stderr, "%s exiting\n", argv[0]);
1034
/* Cleanup things */
1036
avahi_s_service_browser_free(sb);
1038
if (mc.server != NULL)
1039
avahi_server_free(mc.server);
1041
if (mc.simple_poll != NULL)
1042
avahi_simple_poll_free(mc.simple_poll);
1043
free(pubkeyfilename);
1044
free(seckeyfilename);
1046
if (gnutls_initalized){
1047
gnutls_certificate_free_credentials(mc.cred);
1048
gnutls_global_deinit ();
1277
fprintf(stderr, "%s exiting\n", argv[0]);
1280
/* Cleanup things */
1282
avahi_s_service_browser_free(sb);
1284
if(mc.server != NULL)
1285
avahi_server_free(mc.server);
1287
if(mc.simple_poll != NULL)
1288
avahi_simple_poll_free(mc.simple_poll);
1290
if(gnutls_initialized){
1291
gnutls_certificate_free_credentials(mc.cred);
1292
gnutls_global_deinit();
1293
gnutls_dh_params_deinit(mc.dh_params);
1296
if(gpgme_initialized){
1297
gpgme_release(mc.ctx);
1300
/* Removes the temp directory used by GPGME */
1301
if(tempdir_created){
1303
struct dirent *direntry;
1304
d = opendir(tempdir);
1306
if(errno != ENOENT){
1311
direntry = readdir(d);
1312
if(direntry == NULL){
1315
/* Skip "." and ".." */
1316
if(direntry->d_name[0] == '.'
1317
and (direntry->d_name[1] == '\0'
1318
or (direntry->d_name[1] == '.'
1319
and direntry->d_name[2] == '\0'))){
1322
char *fullname = NULL;
1323
ret = asprintf(&fullname, "%s/%s", tempdir,
1329
ret = remove(fullname);
1331
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1338
ret = rmdir(tempdir);
1339
if(ret == -1 and errno != ENOENT){