31
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
32
34
#define _LARGEFILE_SOURCE
36
#ifndef _FILE_OFFSET_BITS
33
37
#define _FILE_OFFSET_BITS 64
35
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */
41
#include <net/if.h> /* if_nametoindex */
42
#include <sys/ioctl.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t */
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
48
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
51
#include <sys/ioctl.h> /* ioctl */
52
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
sockaddr_in6, PF_INET6,
54
SOCK_STREAM, uid_t, gid_t, open(),
56
#include <sys/stat.h> /* open() */
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
64
#include <assert.h> /* assert() */
65
#include <errno.h> /* perror(), errno */
66
#include <time.h> /* nanosleep(), time() */
44
67
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
68
SIOCSIFFLAGS, if_indextoname(),
69
if_nametoindex(), IF_NAMESIZE */
70
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
71
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
getuid(), getgid(), setuid(),
76
#include <arpa/inet.h> /* inet_pton(), htons */
77
#include <iso646.h> /* not, or, and */
78
#include <argp.h> /* struct argp_option, error_t, struct
79
argp_state, struct argp,
80
argp_parse(), ARGP_KEY_ARG,
81
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
82
#include <signal.h> /* sigemptyset(), sigaddset(),
83
sigaction(), SIGTERM, sig_atomic_t,
87
#include <sys/klog.h> /* klogctl() */
88
#endif /* __linux__ */
91
/* All Avahi types, constants and functions
47
94
#include <avahi-core/core.h>
48
95
#include <avahi-core/lookup.h>
49
96
#include <avahi-core/log.h>
111
* Decrypt OpenPGP data using keyrings in HOMEDIR.
112
* Returns -1 on error
114
static ssize_t pgp_packet_decrypt (const char *cryptotext,
117
const char *homedir){
118
gpgme_data_t dh_crypto, dh_plain;
165
static bool init_gpgme(const char *seckey,
166
const char *pubkey, const char *tempdir){
120
168
gpgme_error_t rc;
122
size_t plaintext_capacity = 0;
123
ssize_t plaintext_length = 0;
124
169
gpgme_engine_info_t engine_info;
127
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
173
* Helper function to insert pub and seckey to the engine keyring.
175
bool import_key(const char *filename){
177
gpgme_data_t pgp_data;
179
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
185
rc = gpgme_data_new_from_fd(&pgp_data, fd);
186
if(rc != GPG_ERR_NO_ERROR){
187
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
188
gpgme_strsource(rc), gpgme_strerror(rc));
192
rc = gpgme_op_import(mc.ctx, pgp_data);
193
if(rc != GPG_ERR_NO_ERROR){
194
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
195
gpgme_strsource(rc), gpgme_strerror(rc));
199
ret = (int)TEMP_FAILURE_RETRY(close(fd));
203
gpgme_data_release(pgp_data);
208
fprintf(stderr, "Initializing GPGME\n");
131
212
gpgme_check_version(NULL);
132
213
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
133
if (rc != GPG_ERR_NO_ERROR){
214
if(rc != GPG_ERR_NO_ERROR){
134
215
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
135
216
gpgme_strsource(rc), gpgme_strerror(rc));
139
/* Set GPGME home directory for the OpenPGP engine only */
140
rc = gpgme_get_engine_info (&engine_info);
141
if (rc != GPG_ERR_NO_ERROR){
220
/* Set GPGME home directory for the OpenPGP engine only */
221
rc = gpgme_get_engine_info(&engine_info);
222
if(rc != GPG_ERR_NO_ERROR){
142
223
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
143
224
gpgme_strsource(rc), gpgme_strerror(rc));
146
227
while(engine_info != NULL){
147
228
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
148
229
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
149
engine_info->file_name, homedir);
230
engine_info->file_name, tempdir);
152
233
engine_info = engine_info->next;
154
235
if(engine_info == NULL){
155
fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
236
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
240
/* Create new GPGME "context" */
241
rc = gpgme_new(&(mc.ctx));
242
if(rc != GPG_ERR_NO_ERROR){
243
fprintf(stderr, "bad gpgme_new: %s: %s\n",
244
gpgme_strsource(rc), gpgme_strerror(rc));
248
if(not import_key(pubkey) or not import_key(seckey)){
256
* Decrypt OpenPGP data.
257
* Returns -1 on error
259
static ssize_t pgp_packet_decrypt(const char *cryptotext,
262
gpgme_data_t dh_crypto, dh_plain;
265
size_t plaintext_capacity = 0;
266
ssize_t plaintext_length = 0;
269
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
159
272
/* Create new GPGME data buffer from memory cryptotext */
160
273
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
162
if (rc != GPG_ERR_NO_ERROR){
275
if(rc != GPG_ERR_NO_ERROR){
163
276
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
164
277
gpgme_strsource(rc), gpgme_strerror(rc));
317
418
/* OpenPGP credentials */
318
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
319
!= GNUTLS_E_SUCCESS) {
320
fprintf (stderr, "GnuTLS memory error: %s\n",
321
safer_gnutls_strerror(ret));
322
gnutls_global_deinit ();
419
gnutls_certificate_allocate_credentials(&mc.cred);
420
if(ret != GNUTLS_E_SUCCESS){
421
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
425
safer_gnutls_strerror(ret));
426
gnutls_global_deinit();
327
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
328
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
431
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
432
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
332
436
ret = gnutls_certificate_set_openpgp_key_file
333
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
334
if (ret != GNUTLS_E_SUCCESS) {
437
(mc.cred, pubkeyfilename, seckeyfilename,
438
GNUTLS_OPENPGP_FMT_BASE64);
439
if(ret != GNUTLS_E_SUCCESS){
336
441
"Error[%d] while reading the OpenPGP key pair ('%s',"
337
" '%s')\n", ret, pubkeyfile, seckeyfile);
338
fprintf(stdout, "The GnuTLS error is: %s\n",
442
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
443
fprintf(stderr, "The GnuTLS error is: %s\n",
339
444
safer_gnutls_strerror(ret));
343
448
/* GnuTLS server initialization */
344
ret = gnutls_dh_params_init(&mc->dh_params);
345
if (ret != GNUTLS_E_SUCCESS) {
346
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
347
" %s\n", safer_gnutls_strerror(ret));
350
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
351
if (ret != GNUTLS_E_SUCCESS) {
352
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
353
safer_gnutls_strerror(ret));
357
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
449
ret = gnutls_dh_params_init(&mc.dh_params);
450
if(ret != GNUTLS_E_SUCCESS){
451
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
452
" %s\n", safer_gnutls_strerror(ret));
455
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
456
if(ret != GNUTLS_E_SUCCESS){
457
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
458
safer_gnutls_strerror(ret));
462
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
363
gnutls_certificate_free_credentials (mc->cred);
364
gnutls_global_deinit ();
468
gnutls_certificate_free_credentials(mc.cred);
469
gnutls_global_deinit();
470
gnutls_dh_params_deinit(mc.dh_params);
369
static int init_gnutls_session(mandos_context *mc,
370
gnutls_session_t *session){
474
static int init_gnutls_session(gnutls_session_t *session){
372
476
/* GnuTLS session creation */
373
477
ret = gnutls_init(session, GNUTLS_SERVER);
374
if (ret != GNUTLS_E_SUCCESS){
478
if(ret != GNUTLS_E_SUCCESS){
375
479
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
376
480
safer_gnutls_strerror(ret));
381
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
382
if (ret != GNUTLS_E_SUCCESS) {
485
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
486
if(ret != GNUTLS_E_SUCCESS){
383
487
fprintf(stderr, "Syntax error at: %s\n", err);
384
488
fprintf(stderr, "GnuTLS error: %s\n",
385
489
safer_gnutls_strerror(ret));
386
gnutls_deinit (*session);
490
gnutls_deinit(*session);
391
495
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
393
if (ret != GNUTLS_E_SUCCESS) {
497
if(ret != GNUTLS_E_SUCCESS){
394
498
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
395
499
safer_gnutls_strerror(ret));
396
gnutls_deinit (*session);
500
gnutls_deinit(*session);
400
504
/* ignore client certificate if any. */
401
gnutls_certificate_server_set_request (*session,
505
gnutls_certificate_server_set_request(*session,
404
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
508
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
715
/* Combines file name and path and returns the malloced new
716
string. some sane checks could/should be added */
717
static const char *combinepath(const char *first, const char *second){
718
size_t f_len = strlen(first);
719
size_t s_len = strlen(second);
720
char *tmp = malloc(f_len + s_len + 2);
725
memcpy(tmp, first, f_len); /* Spurious warning */
729
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
731
tmp[f_len + 1 + s_len] = '\0';
885
/* stop main loop after sigterm has been called */
886
static void handle_sigterm(int sig){
891
signal_received = sig;
892
int old_errno = errno;
893
if(mc.simple_poll != NULL){
894
avahi_simple_poll_quit(mc.simple_poll);
736
899
int main(int argc, char *argv[]){
737
AvahiSServiceBrowser *sb = NULL;
740
int exitcode = EXIT_SUCCESS;
741
const char *interface = "eth0";
742
struct ifreq network;
746
char *connect_to = NULL;
747
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
748
const char *pubkeyfile = "pubkey.txt";
749
const char *seckeyfile = "seckey.txt";
750
mandos_context mc = { .simple_poll = NULL, .server = NULL,
751
.dh_bits = 1024, .priority = "SECURE256"};
752
bool gnutls_initalized = false;
900
AvahiSServiceBrowser *sb = NULL;
905
int exitcode = EXIT_SUCCESS;
906
const char *interface = "eth0";
907
struct ifreq network;
909
bool take_down_interface = false;
912
char *connect_to = NULL;
913
char tempdir[] = "/tmp/mandosXXXXXX";
914
bool tempdir_created = false;
915
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
916
const char *seckey = PATHDIR "/" SECKEY;
917
const char *pubkey = PATHDIR "/" PUBKEY;
919
bool gnutls_initialized = false;
920
bool gpgme_initialized = false;
923
struct sigaction old_sigterm_action;
924
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
927
struct argp_option options[] = {
928
{ .name = "debug", .key = 128,
929
.doc = "Debug mode", .group = 3 },
930
{ .name = "connect", .key = 'c',
931
.arg = "ADDRESS:PORT",
932
.doc = "Connect directly to a specific Mandos server",
934
{ .name = "interface", .key = 'i',
936
.doc = "Network interface that will be used to search for"
939
{ .name = "seckey", .key = 's',
941
.doc = "OpenPGP secret key file base name",
943
{ .name = "pubkey", .key = 'p',
945
.doc = "OpenPGP public key file base name",
947
{ .name = "dh-bits", .key = 129,
949
.doc = "Bit length of the prime number used in the"
950
" Diffie-Hellman key exchange",
952
{ .name = "priority", .key = 130,
954
.doc = "GnuTLS priority string for the TLS handshake",
956
{ .name = "delay", .key = 131,
958
.doc = "Maximum delay to wait for interface startup",
755
struct argp_option options[] = {
756
{ .name = "debug", .key = 128,
757
.doc = "Debug mode", .group = 3 },
758
{ .name = "connect", .key = 'c',
760
.doc = "Connect directly to a sepcified mandos server",
762
{ .name = "interface", .key = 'i',
764
.doc = "Interface that Avahi will conntect through",
766
{ .name = "keydir", .key = 'd',
768
.doc = "Directory where the openpgp keyring is",
770
{ .name = "seckey", .key = 's',
772
.doc = "Secret openpgp key for gnutls authentication",
774
{ .name = "pubkey", .key = 'p',
776
.doc = "Public openpgp key for gnutls authentication",
778
{ .name = "dh-bits", .key = 129,
780
.doc = "dh-bits to use in gnutls communication",
782
{ .name = "priority", .key = 130,
784
.doc = "GNUTLS priority", .group = 1 },
789
error_t parse_opt (int key, char *arg,
790
struct argp_state *state) {
791
/* Get the INPUT argument from `argp_parse', which we know is
792
a pointer to our plugin list pointer. */
814
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
829
return ARGP_ERR_UNKNOWN;
963
error_t parse_opt(int key, char *arg,
964
struct argp_state *state){
966
case 128: /* --debug */
969
case 'c': /* --connect */
972
case 'i': /* --interface */
975
case 's': /* --seckey */
978
case 'p': /* --pubkey */
981
case 129: /* --dh-bits */
983
tmpmax = strtoimax(arg, &tmp, 10);
984
if(errno != 0 or tmp == arg or *tmp != '\0'
985
or tmpmax != (typeof(mc.dh_bits))tmpmax){
986
fprintf(stderr, "Bad number of DH bits\n");
989
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
991
case 130: /* --priority */
994
case 131: /* --delay */
996
delay = strtof(arg, &tmp);
997
if(errno != 0 or tmp == arg or *tmp != '\0'){
998
fprintf(stderr, "Bad delay\n");
1007
return ARGP_ERR_UNKNOWN;
834
struct argp argp = { .options = options, .parser = parse_opt,
836
.doc = "Mandos client -- Get and decrypt"
837
" passwords from mandos server" };
838
argp_parse (&argp, argc, argv, 0, 0, NULL);
841
pubkeyfile = combinepath(keydir, pubkeyfile);
842
if (pubkeyfile == NULL){
843
perror("combinepath");
844
exitcode = EXIT_FAILURE;
848
seckeyfile = combinepath(keydir, seckeyfile);
849
if (seckeyfile == NULL){
850
perror("combinepath");
854
ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
856
fprintf(stderr, "init_gnutls_global\n");
859
gnutls_initalized = true;
1012
struct argp argp = { .options = options, .parser = parse_opt,
1014
.doc = "Mandos client -- Get and decrypt"
1015
" passwords from a Mandos server" };
1016
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
1017
if(ret == ARGP_ERR_UNKNOWN){
1018
fprintf(stderr, "Unknown error while parsing arguments\n");
1019
exitcode = EXIT_FAILURE;
1025
avahi_set_log_function(empty_log);
1028
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1029
from the signal handler */
1030
/* Initialize the pseudo-RNG for Avahi */
1031
srand((unsigned int) time(NULL));
1032
mc.simple_poll = avahi_simple_poll_new();
1033
if(mc.simple_poll == NULL){
1034
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1035
exitcode = EXIT_FAILURE;
1039
sigemptyset(&sigterm_action.sa_mask);
1040
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1042
perror("sigaddset");
1043
exitcode = EXIT_FAILURE;
1046
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1048
perror("sigaddset");
1049
exitcode = EXIT_FAILURE;
1052
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1054
perror("sigaddset");
1055
exitcode = EXIT_FAILURE;
1058
/* Need to check if the handler is SIG_IGN before handling:
1059
| [[info:libc:Initial Signal Actions]] |
1060
| [[info:libc:Basic Signal Handling]] |
1062
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1064
perror("sigaction");
1065
return EXIT_FAILURE;
1067
if(old_sigterm_action.sa_handler != SIG_IGN){
1068
ret = sigaction(SIGINT, &sigterm_action, NULL);
1070
perror("sigaction");
1071
exitcode = EXIT_FAILURE;
1075
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1077
perror("sigaction");
1078
return EXIT_FAILURE;
1080
if(old_sigterm_action.sa_handler != SIG_IGN){
1081
ret = sigaction(SIGHUP, &sigterm_action, NULL);
1083
perror("sigaction");
1084
exitcode = EXIT_FAILURE;
1088
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1090
perror("sigaction");
1091
return EXIT_FAILURE;
1093
if(old_sigterm_action.sa_handler != SIG_IGN){
1094
ret = sigaction(SIGTERM, &sigterm_action, NULL);
1096
perror("sigaction");
1097
exitcode = EXIT_FAILURE;
1102
/* If the interface is down, bring it up */
1103
if(interface[0] != '\0'){
875
1104
if_index = (AvahiIfIndex) if_nametoindex(interface);
876
1105
if(if_index == 0){
877
1106
fprintf(stderr, "No such interface: \"%s\"\n", interface);
881
if(connect_to != NULL){
882
/* Connect directly, do not use Zeroconf */
883
/* (Mainly meant for debugging) */
884
char *address = strrchr(connect_to, ':');
886
fprintf(stderr, "No colon in address\n");
887
exitcode = EXIT_FAILURE;
891
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
893
perror("Bad port number");
894
exitcode = EXIT_FAILURE;
898
address = connect_to;
899
ret = start_mandos_communication(address, port, if_index, &mc);
901
exitcode = EXIT_FAILURE;
903
exitcode = EXIT_SUCCESS;
908
/* If the interface is down, bring it up */
910
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
913
exitcode = EXIT_FAILURE;
916
strcpy(network.ifr_name, interface); /* Spurious warning */
1107
exitcode = EXIT_FAILURE;
1116
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1117
messages to mess up the prompt */
1118
ret = klogctl(8, NULL, 5);
1119
bool restore_loglevel = true;
1121
restore_loglevel = false;
1124
#endif /* __linux__ */
1126
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1129
exitcode = EXIT_FAILURE;
1131
if(restore_loglevel){
1132
ret = klogctl(7, NULL, 0);
1137
#endif /* __linux__ */
1140
strcpy(network.ifr_name, interface);
1141
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1143
perror("ioctl SIOCGIFFLAGS");
1145
if(restore_loglevel){
1146
ret = klogctl(7, NULL, 0);
1151
#endif /* __linux__ */
1152
exitcode = EXIT_FAILURE;
1155
if((network.ifr_flags & IFF_UP) == 0){
1156
network.ifr_flags |= IFF_UP;
1157
take_down_interface = true;
1158
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1160
take_down_interface = false;
1161
perror("ioctl SIOCSIFFLAGS");
1162
exitcode = EXIT_FAILURE;
1164
if(restore_loglevel){
1165
ret = klogctl(7, NULL, 0);
1170
#endif /* __linux__ */
1174
/* sleep checking until interface is running */
1175
for(int i=0; i < delay * 4; i++){
917
1176
ret = ioctl(sd, SIOCGIFFLAGS, &network);
919
1178
perror("ioctl SIOCGIFFLAGS");
920
exitcode = EXIT_FAILURE;
923
if((network.ifr_flags & IFF_UP) == 0){
924
network.ifr_flags |= IFF_UP;
925
ret = ioctl(sd, SIOCSIFFLAGS, &network);
927
perror("ioctl SIOCSIFFLAGS");
928
exitcode = EXIT_FAILURE;
936
avahi_set_log_function(empty_log);
939
/* Initialize the pseudo-RNG for Avahi */
940
srand((unsigned int) time(NULL));
942
/* Allocate main Avahi loop object */
943
mc.simple_poll = avahi_simple_poll_new();
944
if (mc.simple_poll == NULL) {
945
fprintf(stderr, "Avahi: Failed to create simple poll"
947
exitcode = EXIT_FAILURE;
952
AvahiServerConfig config;
953
/* Do not publish any local Zeroconf records */
954
avahi_server_config_init(&config);
955
config.publish_hinfo = 0;
956
config.publish_addresses = 0;
957
config.publish_workstation = 0;
958
config.publish_domain = 0;
960
/* Allocate a new server */
961
mc.server = avahi_server_new(avahi_simple_poll_get
962
(mc.simple_poll), &config, NULL,
965
/* Free the Avahi configuration data */
966
avahi_server_config_free(&config);
969
/* Check if creating the Avahi server object succeeded */
970
if (mc.server == NULL) {
971
fprintf(stderr, "Failed to create Avahi server: %s\n",
972
avahi_strerror(error));
973
exitcode = EXIT_FAILURE;
977
/* Create the Avahi service browser */
978
sb = avahi_s_service_browser_new(mc.server, if_index,
980
"_mandos._tcp", NULL, 0,
981
browse_callback, &mc);
983
fprintf(stderr, "Failed to create service browser: %s\n",
984
avahi_strerror(avahi_server_errno(mc.server)));
985
exitcode = EXIT_FAILURE;
989
/* Run the main loop */
992
fprintf(stderr, "Starting Avahi loop search\n");
995
avahi_simple_poll_loop(mc.simple_poll);
1179
} else if(network.ifr_flags & IFF_RUNNING){
1182
struct timespec sleeptime = { .tv_nsec = 250000000 };
1183
ret = nanosleep(&sleeptime, NULL);
1184
if(ret == -1 and errno != EINTR){
1185
perror("nanosleep");
1188
if(not take_down_interface){
1189
/* We won't need the socket anymore */
1190
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1196
if(restore_loglevel){
1197
/* Restores kernel loglevel to default */
1198
ret = klogctl(7, NULL, 0);
1203
#endif /* __linux__ */
1228
ret = init_gnutls_global(pubkey, seckey);
1230
fprintf(stderr, "init_gnutls_global failed\n");
1231
exitcode = EXIT_FAILURE;
1234
gnutls_initialized = true;
1241
tempdir_created = true;
1242
if(mkdtemp(tempdir) == NULL){
1243
tempdir_created = false;
1252
if(not init_gpgme(pubkey, seckey, tempdir)){
1253
fprintf(stderr, "init_gpgme failed\n");
1254
exitcode = EXIT_FAILURE;
1257
gpgme_initialized = true;
1264
if(connect_to != NULL){
1265
/* Connect directly, do not use Zeroconf */
1266
/* (Mainly meant for debugging) */
1267
char *address = strrchr(connect_to, ':');
1268
if(address == NULL){
1269
fprintf(stderr, "No colon in address\n");
1270
exitcode = EXIT_FAILURE;
1280
tmpmax = strtoimax(address+1, &tmp, 10);
1281
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1282
or tmpmax != (uint16_t)tmpmax){
1283
fprintf(stderr, "Bad port number\n");
1284
exitcode = EXIT_FAILURE;
1292
port = (uint16_t)tmpmax;
1294
address = connect_to;
1295
/* Colon in address indicates IPv6 */
1297
if(strchr(address, ':') != NULL){
1307
ret = start_mandos_communication(address, port, if_index, af);
1309
exitcode = EXIT_FAILURE;
1311
exitcode = EXIT_SUCCESS;
1321
AvahiServerConfig config;
1322
/* Do not publish any local Zeroconf records */
1323
avahi_server_config_init(&config);
1324
config.publish_hinfo = 0;
1325
config.publish_addresses = 0;
1326
config.publish_workstation = 0;
1327
config.publish_domain = 0;
1329
/* Allocate a new server */
1330
mc.server = avahi_server_new(avahi_simple_poll_get
1331
(mc.simple_poll), &config, NULL,
1334
/* Free the Avahi configuration data */
1335
avahi_server_config_free(&config);
1338
/* Check if creating the Avahi server object succeeded */
1339
if(mc.server == NULL){
1340
fprintf(stderr, "Failed to create Avahi server: %s\n",
1341
avahi_strerror(error));
1342
exitcode = EXIT_FAILURE;
1350
/* Create the Avahi service browser */
1351
sb = avahi_s_service_browser_new(mc.server, if_index,
1352
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1353
NULL, 0, browse_callback, NULL);
1355
fprintf(stderr, "Failed to create service browser: %s\n",
1356
avahi_strerror(avahi_server_errno(mc.server)));
1357
exitcode = EXIT_FAILURE;
1365
/* Run the main loop */
1368
fprintf(stderr, "Starting Avahi loop search\n");
1371
avahi_simple_poll_loop(mc.simple_poll);
1000
fprintf(stderr, "%s exiting\n", argv[0]);
1003
/* Cleanup things */
1005
avahi_s_service_browser_free(sb);
1007
if (mc.server != NULL)
1008
avahi_server_free(mc.server);
1010
if (mc.simple_poll != NULL)
1011
avahi_simple_poll_free(mc.simple_poll);
1015
if (gnutls_initalized){
1016
gnutls_certificate_free_credentials (mc.cred);
1017
gnutls_global_deinit ();
1376
fprintf(stderr, "%s exiting\n", argv[0]);
1379
/* Cleanup things */
1381
avahi_s_service_browser_free(sb);
1383
if(mc.server != NULL)
1384
avahi_server_free(mc.server);
1386
if(mc.simple_poll != NULL)
1387
avahi_simple_poll_free(mc.simple_poll);
1389
if(gnutls_initialized){
1390
gnutls_certificate_free_credentials(mc.cred);
1391
gnutls_global_deinit();
1392
gnutls_dh_params_deinit(mc.dh_params);
1395
if(gpgme_initialized){
1396
gpgme_release(mc.ctx);
1399
/* Take down the network interface */
1400
if(take_down_interface){
1401
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1403
perror("ioctl SIOCGIFFLAGS");
1404
} else if(network.ifr_flags & IFF_UP) {
1405
network.ifr_flags &= ~IFF_UP; /* clear flag */
1406
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1408
perror("ioctl SIOCSIFFLAGS");
1411
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1417
/* Removes the temp directory used by GPGME */
1418
if(tempdir_created){
1420
struct dirent *direntry;
1421
d = opendir(tempdir);
1423
if(errno != ENOENT){
1428
direntry = readdir(d);
1429
if(direntry == NULL){
1432
/* Skip "." and ".." */
1433
if(direntry->d_name[0] == '.'
1434
and (direntry->d_name[1] == '\0'
1435
or (direntry->d_name[1] == '.'
1436
and direntry->d_name[2] == '\0'))){
1439
char *fullname = NULL;
1440
ret = asprintf(&fullname, "%s/%s", tempdir,
1446
ret = remove(fullname);
1448
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1455
ret = rmdir(tempdir);
1456
if(ret == -1 and errno != ENOENT){
1462
sigemptyset(&old_sigterm_action.sa_mask);
1463
old_sigterm_action.sa_handler = SIG_DFL;
1464
ret = sigaction(signal_received, &old_sigterm_action, NULL);
1466
perror("sigaction");
1468
raise(signal_received);