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 594.1.2
- compare with another revision
- download diff
- download tarball
- view history from revision 594.1.2
- Committer: Teddy Hogeborn
- Date: 2012-06-07 21:00:57 UTC
- mto: This revision was merged to the branch mainline in revision 596.
- Revision ID: teddy@recompile.se-20120607210057-9k4mou58uht7sj2m
* plugins.d/mandos-client.c (bring_up_interface): Bug fix: Return
errno code. Don't
modify errno.
errno code. Don't
modify errno.
- files added:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- network-hooks.d
- files removed:
- ca.pem
- files renamed:
- mandos-clients.conf => clients.conf
- server.py => mandos
- plugbasedclient.c => plugin-runner.c
- plugins.d/mandosclient.c => plugins.d/mandos-client.c
- plugins.d/passprompt.c => plugins.d/password-prompt.c
- files modified:
- Makefile
added
removed
plugins.d/mandos-client.c
1
1
/* -*- coding: utf-8 -*- */
2
2
/*
3
* Mandos client - get and decrypt data from a Mandos server
3
* Mandos-client - get and decrypt data from a Mandos server
4
4
*
5
5
* This program is partly derived from an example program for an Avahi
6
6
* service browser, downloaded from
8
8
* includes the following functions: "resolve_callback",
9
9
* "browse_callback", and parts of "main".
10
10
*
11
* Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
12
* Påhlsson.
11
* Everything else is
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
13
14
*
14
15
* This program is free software: you can redistribute it and/or
15
16
* modify it under the terms of the GNU General Public License as
25
26
* along with this program. If not, see
26
27
* <http://www.gnu.org/licenses/>.
27
28
*
28
* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
29
* <https://www.fukt.bsnet.se/~teddy/>.
29
* Contact the authors at <mandos@recompile.se>.
30
30
*/
31
31
32
#define _FORTIFY_SOURCE 2
33
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
#endif
36
#ifndef _FILE_OFFSET_BITS
35
37
#define _FILE_OFFSET_BITS 64
36
37
#include <stdio.h>
38
#include <assert.h>
39
#include <stdlib.h>
40
#include <time.h>
41
#include <net/if.h> /* if_nametoindex */
42
38
#endif
39
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
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(),
55
opendir(), DIR */
56
#include <sys/stat.h> /* open(), S_ISREG */
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()
61
*/
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
strtoimax() */
64
#include <assert.h> /* assert() */
65
#include <errno.h> /* perror(), errno,
66
program_invocation_short_name */
67
#include <time.h> /* nanosleep(), time(), sleep() */
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
69
SIOCSIFFLAGS, if_indextoname(),
70
if_nametoindex(), IF_NAMESIZE */
71
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
72
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
*/
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
78
#include <iso646.h> /* not, or, and */
79
#include <argp.h> /* struct argp_option, error_t, struct
80
argp_state, struct argp,
81
argp_parse(), ARGP_KEY_ARG,
82
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
83
#include <signal.h> /* sigemptyset(), sigaddset(),
84
sigaction(), SIGTERM, sig_atomic_t,
85
raise() */
86
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
WEXITSTATUS(), WTERMSIG() */
90
#include <grp.h> /* setgroups() */
91
92
#ifdef __linux__
93
#include <sys/klog.h> /* klogctl() */
94
#endif /* __linux__ */
95
96
/* Avahi */
97
/* All Avahi types, constants and functions
98
Avahi*, avahi_*,
99
AVAHI_* */
43
100
#include <avahi-core/core.h>
44
101
#include <avahi-core/lookup.h>
45
102
#include <avahi-core/log.h>
47
104
#include <avahi-common/malloc.h>
48
105
#include <avahi-common/error.h>
49
106
50
//mandos client part
51
#include <sys/types.h> /* socket(), inet_pton() */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton() */
54
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
55
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
56
57
#include <unistd.h> /* close() */
58
#include <netinet/in.h>
59
#include <stdbool.h> /* true */
60
#include <string.h> /* memset */
61
#include <arpa/inet.h> /* inet_pton() */
62
#include <iso646.h> /* not */
63
64
// gpgme
65
#include <errno.h> /* perror() */
66
#include <gpgme.h>
67
68
// getopt long
69
#include <getopt.h>
70
71
#ifndef CERT_ROOT
72
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
73
#endif
74
#define CERTFILE CERT_ROOT "openpgp-client.txt"
75
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
107
/* GnuTLS */
108
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
109
functions:
110
gnutls_*
111
init_gnutls_session(),
112
GNUTLS_* */
113
#include <gnutls/openpgp.h>
114
/* gnutls_certificate_set_openpgp_key_file(),
115
GNUTLS_OPENPGP_FMT_BASE64 */
116
117
/* GPGME */
118
#include <gpgme.h> /* All GPGME types, constants and
119
functions:
120
gpgme_*
121
GPGME_PROTOCOL_OpenPGP,
122
GPG_ERR_NO_* */
123
76
124
#define BUFFER_SIZE 256
77
#define DH_BITS 1024
125
126
#define PATHDIR "/conf/conf.d/mandos"
127
#define SECKEY "seckey.txt"
128
#define PUBKEY "pubkey.txt"
129
#define HOOKDIR "/lib/mandos/network-hooks.d"
78
130
79
131
bool debug = false;
80
132
static const char mandos_protocol_version[] = "1";
133
const char *argp_program_version = "mandos-client " VERSION;
134
const char *argp_program_bug_address = "<mandos@recompile.se>";
135
static const char sys_class_net[] = "/sys/class/net";
136
char *connect_to = NULL;
137
const char *hookdir = HOOKDIR;
138
uid_t uid = 65534;
139
gid_t gid = 65534;
140
141
/* Doubly linked list that need to be circularly linked when used */
142
typedef struct server{
143
const char *ip;
144
uint16_t port;
145
AvahiIfIndex if_index;
146
int af;
147
struct timespec last_seen;
148
struct server *next;
149
struct server *prev;
150
} server;
151
152
/* Used for passing in values through the Avahi callback functions */
81
153
typedef struct {
82
gnutls_session_t session;
154
AvahiSimplePoll *simple_poll;
155
AvahiServer *server;
83
156
gnutls_certificate_credentials_t cred;
157
unsigned int dh_bits;
84
158
gnutls_dh_params_t dh_params;
85
} encrypted_session;
86
87
88
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
89
char **new_packet, const char *homedir){
90
gpgme_data_t dh_crypto, dh_plain;
159
const char *priority;
91
160
gpgme_ctx_t ctx;
161
server *current_server;
162
} mandos_context;
163
164
/* global context so signal handler can reach it*/
165
mandos_context mc = { .simple_poll = NULL, .server = NULL,
166
.dh_bits = 1024, .priority = "SECURE256"
167
":!CTYPE-X.509:+CTYPE-OPENPGP",
168
.current_server = NULL };
169
170
sig_atomic_t quit_now = 0;
171
int signal_received = 0;
172
173
/* Function to use when printing errors */
174
void perror_plus(const char *print_text){
175
int e = errno;
176
fprintf(stderr, "Mandos plugin %s: ",
177
program_invocation_short_name);
178
errno = e;
179
perror(print_text);
180
}
181
182
__attribute__((format (gnu_printf, 2, 3)))
183
int fprintf_plus(FILE *stream, const char *format, ...){
184
va_list ap;
185
va_start (ap, format);
186
187
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
188
program_invocation_short_name));
189
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
190
}
191
192
/*
193
* Make additional room in "buffer" for at least BUFFER_SIZE more
194
* bytes. "buffer_capacity" is how much is currently allocated,
195
* "buffer_length" is how much is already used.
196
*/
197
size_t incbuffer(char **buffer, size_t buffer_length,
198
size_t buffer_capacity){
199
if(buffer_length + BUFFER_SIZE > buffer_capacity){
200
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
201
if(buffer == NULL){
202
return 0;
203
}
204
buffer_capacity += BUFFER_SIZE;
205
}
206
return buffer_capacity;
207
}
208
209
/* Add server to set of servers to retry periodically */
210
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
211
int af){
212
int ret;
213
server *new_server = malloc(sizeof(server));
214
if(new_server == NULL){
215
perror_plus("malloc");
216
return false;
217
}
218
*new_server = (server){ .ip = strdup(ip),
219
.port = port,
220
.if_index = if_index,
221
.af = af };
222
if(new_server->ip == NULL){
223
perror_plus("strdup");
224
return false;
225
}
226
/* Special case of first server */
227
if (mc.current_server == NULL){
228
new_server->next = new_server;
229
new_server->prev = new_server;
230
mc.current_server = new_server;
231
/* Place the new server last in the list */
232
} else {
233
new_server->next = mc.current_server;
234
new_server->prev = mc.current_server->prev;
235
new_server->prev->next = new_server;
236
mc.current_server->prev = new_server;
237
}
238
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
239
if(ret == -1){
240
perror_plus("clock_gettime");
241
return false;
242
}
243
return true;
244
}
245
246
/*
247
* Initialize GPGME.
248
*/
249
static bool init_gpgme(const char *seckey, const char *pubkey,
250
const char *tempdir){
92
251
gpgme_error_t rc;
93
ssize_t ret;
94
ssize_t new_packet_capacity = 0;
95
ssize_t new_packet_length = 0;
96
252
gpgme_engine_info_t engine_info;
97
98
if (debug){
99
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
253
254
255
/*
256
* Helper function to insert pub and seckey to the engine keyring.
257
*/
258
bool import_key(const char *filename){
259
int ret;
260
int fd;
261
gpgme_data_t pgp_data;
262
263
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
264
if(fd == -1){
265
perror_plus("open");
266
return false;
267
}
268
269
rc = gpgme_data_new_from_fd(&pgp_data, fd);
270
if(rc != GPG_ERR_NO_ERROR){
271
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
272
gpgme_strsource(rc), gpgme_strerror(rc));
273
return false;
274
}
275
276
rc = gpgme_op_import(mc.ctx, pgp_data);
277
if(rc != GPG_ERR_NO_ERROR){
278
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
279
gpgme_strsource(rc), gpgme_strerror(rc));
280
return false;
281
}
282
283
ret = (int)TEMP_FAILURE_RETRY(close(fd));
284
if(ret == -1){
285
perror_plus("close");
286
}
287
gpgme_data_release(pgp_data);
288
return true;
289
}
290
291
if(debug){
292
fprintf_plus(stderr, "Initializing GPGME\n");
100
293
}
101
294
102
295
/* Init GPGME */
103
296
gpgme_check_version(NULL);
104
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
297
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
298
if(rc != GPG_ERR_NO_ERROR){
299
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
300
gpgme_strsource(rc), gpgme_strerror(rc));
301
return false;
302
}
105
303
106
/* Set GPGME home directory */
107
rc = gpgme_get_engine_info (&engine_info);
108
if (rc != GPG_ERR_NO_ERROR){
109
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
110
gpgme_strsource(rc), gpgme_strerror(rc));
111
return -1;
304
/* Set GPGME home directory for the OpenPGP engine only */
305
rc = gpgme_get_engine_info(&engine_info);
306
if(rc != GPG_ERR_NO_ERROR){
307
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
308
gpgme_strsource(rc), gpgme_strerror(rc));
309
return false;
112
310
}
113
311
while(engine_info != NULL){
114
312
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
115
313
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
116
engine_info->file_name, homedir);
314
engine_info->file_name, tempdir);
117
315
break;
118
316
}
119
317
engine_info = engine_info->next;
120
318
}
121
319
if(engine_info == NULL){
122
fprintf(stderr, "Could not set home dir to %s\n", homedir);
123
return -1;
124
}
125
126
/* Create new GPGME data buffer from packet buffer */
127
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
128
if (rc != GPG_ERR_NO_ERROR){
129
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
130
gpgme_strsource(rc), gpgme_strerror(rc));
320
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
321
tempdir);
322
return false;
323
}
324
325
/* Create new GPGME "context" */
326
rc = gpgme_new(&(mc.ctx));
327
if(rc != GPG_ERR_NO_ERROR){
328
fprintf_plus(stderr, "Mandos plugin mandos-client: "
329
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
330
gpgme_strerror(rc));
331
return false;
332
}
333
334
if(not import_key(pubkey) or not import_key(seckey)){
335
return false;
336
}
337
338
return true;
339
}
340
341
/*
342
* Decrypt OpenPGP data.
343
* Returns -1 on error
344
*/
345
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
size_t crypto_size,
347
char **plaintext){
348
gpgme_data_t dh_crypto, dh_plain;
349
gpgme_error_t rc;
350
ssize_t ret;
351
size_t plaintext_capacity = 0;
352
ssize_t plaintext_length = 0;
353
354
if(debug){
355
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
356
}
357
358
/* Create new GPGME data buffer from memory cryptotext */
359
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
360
0);
361
if(rc != GPG_ERR_NO_ERROR){
362
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
363
gpgme_strsource(rc), gpgme_strerror(rc));
131
364
return -1;
132
365
}
133
366
134
367
/* Create new empty GPGME data buffer for the plaintext */
135
368
rc = gpgme_data_new(&dh_plain);
136
if (rc != GPG_ERR_NO_ERROR){
137
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
138
gpgme_strsource(rc), gpgme_strerror(rc));
139
return -1;
140
}
141
142
/* Create new GPGME "context" */
143
rc = gpgme_new(&ctx);
144
if (rc != GPG_ERR_NO_ERROR){
145
fprintf(stderr, "bad gpgme_new: %s: %s\n",
146
gpgme_strsource(rc), gpgme_strerror(rc));
147
return -1;
148
}
149
150
/* Decrypt data from the FILE pointer to the plaintext data
151
buffer */
152
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
153
if (rc != GPG_ERR_NO_ERROR){
154
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
155
gpgme_strsource(rc), gpgme_strerror(rc));
156
return -1;
157
}
158
159
if(debug){
160
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
161
}
162
163
if (debug){
164
gpgme_decrypt_result_t result;
165
result = gpgme_op_decrypt_result(ctx);
166
if (result == NULL){
167
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
168
} else {
169
fprintf(stderr, "Unsupported algorithm: %s\n",
170
result->unsupported_algorithm);
171
fprintf(stderr, "Wrong key usage: %d\n",
172
result->wrong_key_usage);
173
if(result->file_name != NULL){
174
fprintf(stderr, "File name: %s\n", result->file_name);
175
}
176
gpgme_recipient_t recipient;
177
recipient = result->recipients;
178
if(recipient){
369
if(rc != GPG_ERR_NO_ERROR){
370
fprintf_plus(stderr, "Mandos plugin mandos-client: "
371
"bad gpgme_data_new: %s: %s\n",
372
gpgme_strsource(rc), gpgme_strerror(rc));
373
gpgme_data_release(dh_crypto);
374
return -1;
375
}
376
377
/* Decrypt data from the cryptotext data buffer to the plaintext
378
data buffer */
379
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
380
if(rc != GPG_ERR_NO_ERROR){
381
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
382
gpgme_strsource(rc), gpgme_strerror(rc));
383
plaintext_length = -1;
384
if(debug){
385
gpgme_decrypt_result_t result;
386
result = gpgme_op_decrypt_result(mc.ctx);
387
if(result == NULL){
388
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
389
} else {
390
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
391
result->unsupported_algorithm);
392
fprintf_plus(stderr, "Wrong key usage: %u\n",
393
result->wrong_key_usage);
394
if(result->file_name != NULL){
395
fprintf_plus(stderr, "File name: %s\n", result->file_name);
396
}
397
gpgme_recipient_t recipient;
398
recipient = result->recipients;
179
399
while(recipient != NULL){
180
fprintf(stderr, "Public key algorithm: %s\n",
181
gpgme_pubkey_algo_name(recipient->pubkey_algo));
182
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
183
fprintf(stderr, "Secret key available: %s\n",
184
recipient->status == GPG_ERR_NO_SECKEY
185
? "No" : "Yes");
400
fprintf_plus(stderr, "Public key algorithm: %s\n",
401
gpgme_pubkey_algo_name
402
(recipient->pubkey_algo));
403
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
404
fprintf_plus(stderr, "Secret key available: %s\n",
405
recipient->status == GPG_ERR_NO_SECKEY
406
? "No" : "Yes");
186
407
recipient = recipient->next;
187
408
}
188
409
}
189
410
}
411
goto decrypt_end;
190
412
}
191
413
192
/* Delete the GPGME FILE pointer cryptotext data buffer */
193
gpgme_data_release(dh_crypto);
414
if(debug){
415
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
416
}
194
417
195
418
/* Seek back to the beginning of the GPGME plaintext data buffer */
196
gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
197
198
*new_packet = 0;
419
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
420
perror_plus("gpgme_data_seek");
421
plaintext_length = -1;
422
goto decrypt_end;
423
}
424
425
*plaintext = NULL;
199
426
while(true){
200
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
201
*new_packet = realloc(*new_packet,
202
(unsigned int)new_packet_capacity
203
+ BUFFER_SIZE);
204
if (*new_packet == NULL){
205
perror("realloc");
206
return -1;
207
}
208
new_packet_capacity += BUFFER_SIZE;
427
plaintext_capacity = incbuffer(plaintext,
428
(size_t)plaintext_length,
429
plaintext_capacity);
430
if(plaintext_capacity == 0){
431
perror_plus("incbuffer");
432
plaintext_length = -1;
433
goto decrypt_end;
209
434
}
210
435
211
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
436
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
212
437
BUFFER_SIZE);
213
438
/* Print the data, if any */
214
if (ret == 0){
439
if(ret == 0){
440
/* EOF */
215
441
break;
216
442
}
217
443
if(ret < 0){
218
perror("gpgme_data_read");
219
return -1;
220
}
221
new_packet_length += ret;
222
}
223
224
/* FIXME: check characters before printing to screen so to not print
225
terminal control characters */
226
/* if(debug){ */
227
/* fprintf(stderr, "decrypted password is: "); */
228
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
229
/* fprintf(stderr, "\n"); */
230
/* } */
444
perror_plus("gpgme_data_read");
445
plaintext_length = -1;
446
goto decrypt_end;
447
}
448
plaintext_length += ret;
449
}
450
451
if(debug){
452
fprintf_plus(stderr, "Decrypted password is: ");
453
for(ssize_t i = 0; i < plaintext_length; i++){
454
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
455
}
456
fprintf(stderr, "\n");
457
}
458
459
decrypt_end:
460
461
/* Delete the GPGME cryptotext data buffer */
462
gpgme_data_release(dh_crypto);
231
463
232
464
/* Delete the GPGME plaintext data buffer */
233
465
gpgme_data_release(dh_plain);
234
return new_packet_length;
466
return plaintext_length;
235
467
}
236
468
237
static const char * safer_gnutls_strerror (int value) {
238
const char *ret = gnutls_strerror (value);
239
if (ret == NULL)
469
static const char * safer_gnutls_strerror(int value){
470
const char *ret = gnutls_strerror(value); /* Spurious warning from
471
-Wunreachable-code */
472
if(ret == NULL)
240
473
ret = "(unknown)";
241
474
return ret;
242
475
}
243
476
244
void debuggnutls(__attribute__((unused)) int level,
245
const char* string){
246
fprintf(stderr, "%s", string);
477
/* GnuTLS log function callback */
478
static void debuggnutls(__attribute__((unused)) int level,
479
const char* string){
480
fprintf_plus(stderr, "GnuTLS: %s", string);
247
481
}
248
482
249
int initgnutls(encrypted_session *es){
250
const char *err;
483
static int init_gnutls_global(const char *pubkeyfilename,
484
const char *seckeyfilename){
251
485
int ret;
252
486
253
487
if(debug){
254
fprintf(stderr, "Initializing GnuTLS\n");
488
fprintf_plus(stderr, "Initializing GnuTLS\n");
255
489
}
256
490
257
if ((ret = gnutls_global_init ())
258
!= GNUTLS_E_SUCCESS) {
259
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
491
ret = gnutls_global_init();
492
if(ret != GNUTLS_E_SUCCESS){
493
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
494
safer_gnutls_strerror(ret));
260
495
return -1;
261
496
}
262
263
if (debug){
497
498
if(debug){
499
/* "Use a log level over 10 to enable all debugging options."
500
* - GnuTLS manual
501
*/
264
502
gnutls_global_set_log_level(11);
265
503
gnutls_global_set_log_function(debuggnutls);
266
504
}
267
505
268
/* openpgp credentials */
269
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
270
!= GNUTLS_E_SUCCESS) {
271
fprintf (stderr, "memory error: %s\n",
272
safer_gnutls_strerror(ret));
506
/* OpenPGP credentials */
507
ret = gnutls_certificate_allocate_credentials(&mc.cred);
508
if(ret != GNUTLS_E_SUCCESS){
509
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
510
safer_gnutls_strerror(ret));
511
gnutls_global_deinit();
273
512
return -1;
274
513
}
275
514
276
515
if(debug){
277
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
278
" and keyfile %s as GnuTLS credentials\n", CERTFILE,
279
KEYFILE);
516
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
517
" secret key %s as GnuTLS credentials\n",
518
pubkeyfilename,
519
seckeyfilename);
280
520
}
281
521
282
522
ret = gnutls_certificate_set_openpgp_key_file
283
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
284
if (ret != GNUTLS_E_SUCCESS) {
285
fprintf
286
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
287
" '%s')\n",
288
ret, CERTFILE, KEYFILE);
289
fprintf(stdout, "The Error is: %s\n",
290
safer_gnutls_strerror(ret));
291
return -1;
292
}
293
294
//GnuTLS server initialization
295
if ((ret = gnutls_dh_params_init (&es->dh_params))
296
!= GNUTLS_E_SUCCESS) {
297
fprintf (stderr, "Error in dh parameter initialization: %s\n",
298
safer_gnutls_strerror(ret));
299
return -1;
300
}
301
302
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
303
!= GNUTLS_E_SUCCESS) {
304
fprintf (stderr, "Error in prime generation: %s\n",
305
safer_gnutls_strerror(ret));
306
return -1;
307
}
308
309
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
310
311
// GnuTLS session creation
312
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
313
!= GNUTLS_E_SUCCESS){
314
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
315
safer_gnutls_strerror(ret));
316
}
317
318
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
319
!= GNUTLS_E_SUCCESS) {
320
fprintf(stderr, "Syntax error at: %s\n", err);
321
fprintf(stderr, "GnuTLS error: %s\n",
322
safer_gnutls_strerror(ret));
323
return -1;
324
}
325
326
if ((ret = gnutls_credentials_set
327
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
328
!= GNUTLS_E_SUCCESS) {
329
fprintf(stderr, "Error setting a credentials set: %s\n",
330
safer_gnutls_strerror(ret));
523
(mc.cred, pubkeyfilename, seckeyfilename,
524
GNUTLS_OPENPGP_FMT_BASE64);
525
if(ret != GNUTLS_E_SUCCESS){
526
fprintf_plus(stderr,
527
"Error[%d] while reading the OpenPGP key pair ('%s',"
528
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
529
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
530
safer_gnutls_strerror(ret));
531
goto globalfail;
532
}
533
534
/* GnuTLS server initialization */
535
ret = gnutls_dh_params_init(&mc.dh_params);
536
if(ret != GNUTLS_E_SUCCESS){
537
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
538
" initialization: %s\n",
539
safer_gnutls_strerror(ret));
540
goto globalfail;
541
}
542
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
543
if(ret != GNUTLS_E_SUCCESS){
544
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
545
safer_gnutls_strerror(ret));
546
goto globalfail;
547
}
548
549
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
550
551
return 0;
552
553
globalfail:
554
555
gnutls_certificate_free_credentials(mc.cred);
556
gnutls_global_deinit();
557
gnutls_dh_params_deinit(mc.dh_params);
558
return -1;
559
}
560
561
static int init_gnutls_session(gnutls_session_t *session){
562
int ret;
563
/* GnuTLS session creation */
564
do {
565
ret = gnutls_init(session, GNUTLS_SERVER);
566
if(quit_now){
567
return -1;
568
}
569
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
570
if(ret != GNUTLS_E_SUCCESS){
571
fprintf_plus(stderr,
572
"Error in GnuTLS session initialization: %s\n",
573
safer_gnutls_strerror(ret));
574
}
575
576
{
577
const char *err;
578
do {
579
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
580
if(quit_now){
581
gnutls_deinit(*session);
582
return -1;
583
}
584
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
585
if(ret != GNUTLS_E_SUCCESS){
586
fprintf_plus(stderr, "Syntax error at: %s\n", err);
587
fprintf_plus(stderr, "GnuTLS error: %s\n",
588
safer_gnutls_strerror(ret));
589
gnutls_deinit(*session);
590
return -1;
591
}
592
}
593
594
do {
595
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
596
mc.cred);
597
if(quit_now){
598
gnutls_deinit(*session);
599
return -1;
600
}
601
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
602
if(ret != GNUTLS_E_SUCCESS){
603
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
604
safer_gnutls_strerror(ret));
605
gnutls_deinit(*session);
331
606
return -1;
332
607
}
333
608
334
609
/* ignore client certificate if any. */
335
gnutls_certificate_server_set_request (es->session,
336
GNUTLS_CERT_IGNORE);
610
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
337
611
338
gnutls_dh_set_prime_bits (es->session, DH_BITS);
612
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
339
613
340
614
return 0;
341
615
}
342
616
343
void empty_log(__attribute__((unused)) AvahiLogLevel level,
344
__attribute__((unused)) const char *txt){}
617
/* Avahi log function callback */
618
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
619
__attribute__((unused)) const char *txt){}
345
620
346
int start_mandos_communication(const char *ip, uint16_t port,
347
unsigned int if_index){
348
int ret, tcp_sd;
349
struct sockaddr_in6 to;
350
encrypted_session es;
621
/* Called when a Mandos server is found */
622
static int start_mandos_communication(const char *ip, uint16_t port,
623
AvahiIfIndex if_index,
624
int af){
625
int ret, tcp_sd = -1;
626
ssize_t sret;
627
union {
628
struct sockaddr_in in;
629
struct sockaddr_in6 in6;
630
} to;
351
631
char *buffer = NULL;
352
char *decrypted_buffer;
632
char *decrypted_buffer = NULL;
353
633
size_t buffer_length = 0;
354
634
size_t buffer_capacity = 0;
355
ssize_t decrypted_buffer_size;
356
size_t written = 0;
357
int retval = 0;
358
char interface[IF_NAMESIZE];
359
360
if(debug){
361
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
362
}
363
364
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
365
if(tcp_sd < 0) {
366
perror("socket");
367
return -1;
368
}
369
370
if(if_indextoname(if_index, interface) == NULL){
371
if(debug){
372
perror("if_indextoname");
373
}
374
return -1;
375
}
376
377
if(debug){
378
fprintf(stderr, "Binding to interface %s\n", interface);
379
}
380
381
memset(&to,0,sizeof(to)); /* Spurious warning */
382
to.sin6_family = AF_INET6;
383
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
384
if (ret < 0 ){
385
perror("inet_pton");
386
return -1;
387
}
635
size_t written;
636
int retval = -1;
637
gnutls_session_t session;
638
int pf; /* Protocol family */
639
640
errno = 0;
641
642
if(quit_now){
643
errno = EINTR;
644
return -1;
645
}
646
647
switch(af){
648
case AF_INET6:
649
pf = PF_INET6;
650
break;
651
case AF_INET:
652
pf = PF_INET;
653
break;
654
default:
655
fprintf_plus(stderr, "Bad address family: %d\n", af);
656
errno = EINVAL;
657
return -1;
658
}
659
660
ret = init_gnutls_session(&session);
661
if(ret != 0){
662
return -1;
663
}
664
665
if(debug){
666
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
667
PRIu16 "\n", ip, port);
668
}
669
670
tcp_sd = socket(pf, SOCK_STREAM, 0);
671
if(tcp_sd < 0){
672
int e = errno;
673
perror_plus("socket");
674
errno = e;
675
goto mandos_end;
676
}
677
678
if(quit_now){
679
errno = EINTR;
680
goto mandos_end;
681
}
682
683
memset(&to, 0, sizeof(to));
684
if(af == AF_INET6){
685
to.in6.sin6_family = (sa_family_t)af;
686
ret = inet_pton(af, ip, &to.in6.sin6_addr);
687
} else { /* IPv4 */
688
to.in.sin_family = (sa_family_t)af;
689
ret = inet_pton(af, ip, &to.in.sin_addr);
690
}
691
if(ret < 0 ){
692
int e = errno;
693
perror_plus("inet_pton");
694
errno = e;
695
goto mandos_end;
696
}
388
697
if(ret == 0){
389
fprintf(stderr, "Bad address: %s\n", ip);
390
return -1;
391
}
392
to.sin6_port = htons(port); /* Spurious warning */
393
394
to.sin6_scope_id = (uint32_t)if_index;
395
396
if(debug){
397
fprintf(stderr, "Connection to: %s\n", ip);
398
}
399
400
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
401
if (ret < 0){
402
perror("connect");
403
return -1;
404
}
405
406
ret = initgnutls (&es);
407
if (ret != 0){
408
retval = -1;
409
return -1;
410
}
411
412
gnutls_transport_set_ptr (es.session,
413
(gnutls_transport_ptr_t) tcp_sd);
414
415
if(debug){
416
fprintf(stderr, "Establishing TLS session with %s\n", ip);
417
}
418
419
ret = gnutls_handshake (es.session);
420
421
if (ret != GNUTLS_E_SUCCESS){
422
fprintf(stderr, "\n*** Handshake failed ***\n");
423
gnutls_perror (ret);
424
retval = -1;
425
goto exit;
426
}
427
428
//Retrieve OpenPGP packet that contains the wanted password
429
430
if(debug){
431
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
432
ip);
433
}
434
435
while(true){
436
if (buffer_length + BUFFER_SIZE > buffer_capacity){
437
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
438
if (buffer == NULL){
439
perror("realloc");
440
goto exit;
441
}
442
buffer_capacity += BUFFER_SIZE;
443
}
444
445
ret = gnutls_record_recv
446
(es.session, buffer+buffer_length, BUFFER_SIZE);
447
if (ret == 0){
698
int e = errno;
699
fprintf_plus(stderr, "Bad address: %s\n", ip);
700
errno = e;
701
goto mandos_end;
702
}
703
if(af == AF_INET6){
704
to.in6.sin6_port = htons(port); /* Spurious warnings from
705
-Wconversion and
706
-Wunreachable-code */
707
708
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
709
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
710
-Wunreachable-code*/
711
if(if_index == AVAHI_IF_UNSPEC){
712
fprintf_plus(stderr, "An IPv6 link-local address is"
713
" incomplete without a network interface\n");
714
errno = EINVAL;
715
goto mandos_end;
716
}
717
/* Set the network interface number as scope */
718
to.in6.sin6_scope_id = (uint32_t)if_index;
719
}
720
} else {
721
to.in.sin_port = htons(port); /* Spurious warnings from
722
-Wconversion and
723
-Wunreachable-code */
724
}
725
726
if(quit_now){
727
errno = EINTR;
728
goto mandos_end;
729
}
730
731
if(debug){
732
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
733
char interface[IF_NAMESIZE];
734
if(if_indextoname((unsigned int)if_index, interface) == NULL){
735
perror_plus("if_indextoname");
736
} else {
737
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
738
"\n", ip, interface, port);
739
}
740
} else {
741
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
742
ip, port);
743
}
744
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
745
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
746
const char *pcret;
747
if(af == AF_INET6){
748
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
749
sizeof(addrstr));
750
} else {
751
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
752
sizeof(addrstr));
753
}
754
if(pcret == NULL){
755
perror_plus("inet_ntop");
756
} else {
757
if(strcmp(addrstr, ip) != 0){
758
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
759
}
760
}
761
}
762
763
if(quit_now){
764
errno = EINTR;
765
goto mandos_end;
766
}
767
768
if(af == AF_INET6){
769
ret = connect(tcp_sd, &to.in6, sizeof(to));
770
} else {
771
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
772
}
773
if(ret < 0){
774
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
775
int e = errno;
776
perror_plus("connect");
777
errno = e;
778
}
779
goto mandos_end;
780
}
781
782
if(quit_now){
783
errno = EINTR;
784
goto mandos_end;
785
}
786
787
const char *out = mandos_protocol_version;
788
written = 0;
789
while(true){
790
size_t out_size = strlen(out);
791
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
792
out_size - written));
793
if(ret == -1){
794
int e = errno;
795
perror_plus("write");
796
errno = e;
797
goto mandos_end;
798
}
799
written += (size_t)ret;
800
if(written < out_size){
801
continue;
802
} else {
803
if(out == mandos_protocol_version){
804
written = 0;
805
out = "\r\n";
806
} else {
807
break;
808
}
809
}
810
811
if(quit_now){
812
errno = EINTR;
813
goto mandos_end;
814
}
815
}
816
817
if(debug){
818
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
819
}
820
821
if(quit_now){
822
errno = EINTR;
823
goto mandos_end;
824
}
825
826
/* This casting via intptr_t is to eliminate warning about casting
827
an int to a pointer type. This is exactly how the GnuTLS Guile
828
function "set-session-transport-fd!" does it. */
829
gnutls_transport_set_ptr(session,
830
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
831
832
if(quit_now){
833
errno = EINTR;
834
goto mandos_end;
835
}
836
837
do {
838
ret = gnutls_handshake(session);
839
if(quit_now){
840
errno = EINTR;
841
goto mandos_end;
842
}
843
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
844
845
if(ret != GNUTLS_E_SUCCESS){
846
if(debug){
847
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
848
gnutls_perror(ret);
849
}
850
errno = EPROTO;
851
goto mandos_end;
852
}
853
854
/* Read OpenPGP packet that contains the wanted password */
855
856
if(debug){
857
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
858
" %s\n", ip);
859
}
860
861
while(true){
862
863
if(quit_now){
864
errno = EINTR;
865
goto mandos_end;
866
}
867
868
buffer_capacity = incbuffer(&buffer, buffer_length,
869
buffer_capacity);
870
if(buffer_capacity == 0){
871
int e = errno;
872
perror_plus("incbuffer");
873
errno = e;
874
goto mandos_end;
875
}
876
877
if(quit_now){
878
errno = EINTR;
879
goto mandos_end;
880
}
881
882
sret = gnutls_record_recv(session, buffer+buffer_length,
883
BUFFER_SIZE);
884
if(sret == 0){
448
885
break;
449
886
}
450
if (ret < 0){
451
switch(ret){
887
if(sret < 0){
888
switch(sret){
452
889
case GNUTLS_E_INTERRUPTED:
453
890
case GNUTLS_E_AGAIN:
454
891
break;
455
892
case GNUTLS_E_REHANDSHAKE:
456
ret = gnutls_handshake (es.session);
457
if (ret < 0){
458
fprintf(stderr, "\n*** Handshake failed ***\n");
459
gnutls_perror (ret);
460
retval = -1;
461
goto exit;
893
do {
894
ret = gnutls_handshake(session);
895
896
if(quit_now){
897
errno = EINTR;
898
goto mandos_end;
899
}
900
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
901
if(ret < 0){
902
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
903
"***\n");
904
gnutls_perror(ret);
905
errno = EPROTO;
906
goto mandos_end;
462
907
}
463
908
break;
464
909
default:
465
fprintf(stderr, "Unknown error while reading data from"
466
" encrypted session with mandos server\n");
467
retval = -1;
468
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
469
goto exit;
910
fprintf_plus(stderr, "Unknown error while reading data from"
911
" encrypted session with Mandos server\n");
912
gnutls_bye(session, GNUTLS_SHUT_RDWR);
913
errno = EIO;
914
goto mandos_end;
470
915
}
471
916
} else {
472
buffer_length += (size_t) ret;
473
}
474
}
475
476
if (buffer_length > 0){
477
decrypted_buffer_size = pgp_packet_decrypt(buffer,
478
buffer_length,
479
&decrypted_buffer,
480
CERT_ROOT);
481
if (decrypted_buffer_size >= 0){
482
while(written < decrypted_buffer_size){
483
ret = (int)fwrite (decrypted_buffer + written, 1,
484
(size_t)decrypted_buffer_size - written,
485
stdout);
917
buffer_length += (size_t) sret;
918
}
919
}
920
921
if(debug){
922
fprintf_plus(stderr, "Closing TLS session\n");
923
}
924
925
if(quit_now){
926
errno = EINTR;
927
goto mandos_end;
928
}
929
930
do {
931
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
932
if(quit_now){
933
errno = EINTR;
934
goto mandos_end;
935
}
936
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
937
938
if(buffer_length > 0){
939
ssize_t decrypted_buffer_size;
940
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
941
&decrypted_buffer);
942
if(decrypted_buffer_size >= 0){
943
944
written = 0;
945
while(written < (size_t) decrypted_buffer_size){
946
if(quit_now){
947
errno = EINTR;
948
goto mandos_end;
949
}
950
951
ret = (int)fwrite(decrypted_buffer + written, 1,
952
(size_t)decrypted_buffer_size - written,
953
stdout);
486
954
if(ret == 0 and ferror(stdout)){
955
int e = errno;
487
956
if(debug){
488
fprintf(stderr, "Error writing encrypted data: %s\n",
489
strerror(errno));
957
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
958
strerror(errno));
490
959
}
491
retval = -1;
492
break;
960
errno = e;
961
goto mandos_end;
493
962
}
494
963
written += (size_t)ret;
495
964
}
496
free(decrypted_buffer);
497
} else {
965
retval = 0;
966
}
967
}
968
969
/* Shutdown procedure */
970
971
mandos_end:
972
{
973
int e = errno;
974
free(decrypted_buffer);
975
free(buffer);
976
if(tcp_sd >= 0){
977
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
978
}
979
if(ret == -1){
980
if(e == 0){
981
e = errno;
982
}
983
perror_plus("close");
984
}
985
gnutls_deinit(session);
986
errno = e;
987
if(quit_now){
988
errno = EINTR;
498
989
retval = -1;
499
990
}
500
991
}
501
502
//shutdown procedure
503
504
if(debug){
505
fprintf(stderr, "Closing TLS session\n");
506
}
507
508
free(buffer);
509
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
510
exit:
511
close(tcp_sd);
512
gnutls_deinit (es.session);
513
gnutls_certificate_free_credentials (es.cred);
514
gnutls_global_deinit ();
515
992
return retval;
516
993
}
517
994
518
static AvahiSimplePoll *simple_poll = NULL;
519
static AvahiServer *server = NULL;
520
521
static void resolve_callback(
522
AvahiSServiceResolver *r,
523
AvahiIfIndex interface,
524
AVAHI_GCC_UNUSED AvahiProtocol protocol,
525
AvahiResolverEvent event,
526
const char *name,
527
const char *type,
528
const char *domain,
529
const char *host_name,
530
const AvahiAddress *address,
531
uint16_t port,
532
AVAHI_GCC_UNUSED AvahiStringList *txt,
533
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
534
AVAHI_GCC_UNUSED void* userdata) {
535
536
assert(r); /* Spurious warning */
995
static void resolve_callback(AvahiSServiceResolver *r,
996
AvahiIfIndex interface,
997
AvahiProtocol proto,
998
AvahiResolverEvent event,
999
const char *name,
1000
const char *type,
1001
const char *domain,
1002
const char *host_name,
1003
const AvahiAddress *address,
1004
uint16_t port,
1005
AVAHI_GCC_UNUSED AvahiStringList *txt,
1006
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1007
flags,
1008
AVAHI_GCC_UNUSED void* userdata){
1009
assert(r);
537
1010
538
1011
/* Called whenever a service has been resolved successfully or
539
1012
timed out */
540
1013
541
switch (event) {
1014
if(quit_now){
1015
return;
1016
}
1017
1018
switch(event){
542
1019
default:
543
1020
case AVAHI_RESOLVER_FAILURE:
544
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
545
" type '%s' in domain '%s': %s\n", name, type, domain,
546
avahi_strerror(avahi_server_errno(server)));
1021
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1022
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1023
domain,
1024
avahi_strerror(avahi_server_errno(mc.server)));
547
1025
break;
548
1026
549
1027
case AVAHI_RESOLVER_FOUND:
551
1029
char ip[AVAHI_ADDRESS_STR_MAX];
552
1030
avahi_address_snprint(ip, sizeof(ip), address);
553
1031
if(debug){
554
fprintf(stderr, "Mandos server found on %s (%s) on port %d\n",
555
host_name, ip, port);
1032
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1033
PRIdMAX ") on port %" PRIu16 "\n", name,
1034
host_name, ip, (intmax_t)interface, port);
556
1035
}
557
int ret = start_mandos_communication(ip, port,
558
(unsigned int) interface);
559
if (ret == 0){
560
exit(EXIT_SUCCESS);
1036
int ret = start_mandos_communication(ip, port, interface,
1037
avahi_proto_to_af(proto));
1038
if(ret == 0){
1039
avahi_simple_poll_quit(mc.simple_poll);
561
1040
} else {
562
exit(EXIT_FAILURE);
1041
if(not add_server(ip, port, interface,
1042
avahi_proto_to_af(proto))){
1043
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1044
" list\n", name);
1045
}
563
1046
}
564
1047
}
565
1048
}
566
1049
avahi_s_service_resolver_free(r);
567
1050
}
568
1051
569
static void browse_callback(
570
AvahiSServiceBrowser *b,
571
AvahiIfIndex interface,
572
AvahiProtocol protocol,
573
AvahiBrowserEvent event,
574
const char *name,
575
const char *type,
576
const char *domain,
577
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
578
void* userdata) {
579
580
AvahiServer *s = userdata;
581
assert(b); /* Spurious warning */
582
583
/* Called whenever a new services becomes available on the LAN or
584
is removed from the LAN */
585
586
switch (event) {
1052
static void browse_callback(AvahiSServiceBrowser *b,
1053
AvahiIfIndex interface,
1054
AvahiProtocol protocol,
1055
AvahiBrowserEvent event,
1056
const char *name,
1057
const char *type,
1058
const char *domain,
1059
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1060
flags,
1061
AVAHI_GCC_UNUSED void* userdata){
1062
assert(b);
1063
1064
/* Called whenever a new services becomes available on the LAN or
1065
is removed from the LAN */
1066
1067
if(quit_now){
1068
return;
1069
}
1070
1071
switch(event){
1072
default:
1073
case AVAHI_BROWSER_FAILURE:
1074
1075
fprintf_plus(stderr, "(Avahi browser) %s\n",
1076
avahi_strerror(avahi_server_errno(mc.server)));
1077
avahi_simple_poll_quit(mc.simple_poll);
1078
return;
1079
1080
case AVAHI_BROWSER_NEW:
1081
/* We ignore the returned Avahi resolver object. In the callback
1082
function we free it. If the Avahi server is terminated before
1083
the callback function is called the Avahi server will free the
1084
resolver for us. */
1085
1086
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1087
name, type, domain, protocol, 0,
1088
resolve_callback, NULL) == NULL)
1089
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1090
" %s\n", name,
1091
avahi_strerror(avahi_server_errno(mc.server)));
1092
break;
1093
1094
case AVAHI_BROWSER_REMOVE:
1095
break;
1096
1097
case AVAHI_BROWSER_ALL_FOR_NOW:
1098
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1099
if(debug){
1100
fprintf_plus(stderr, "No Mandos server found, still"
1101
" searching...\n");
1102
}
1103
break;
1104
}
1105
}
1106
1107
/* Signal handler that stops main loop after SIGTERM */
1108
static void handle_sigterm(int sig){
1109
if(quit_now){
1110
return;
1111
}
1112
quit_now = 1;
1113
signal_received = sig;
1114
int old_errno = errno;
1115
/* set main loop to exit */
1116
if(mc.simple_poll != NULL){
1117
avahi_simple_poll_quit(mc.simple_poll);
1118
}
1119
errno = old_errno;
1120
}
1121
1122
bool get_flags(const char *ifname, struct ifreq *ifr){
1123
int ret;
1124
1125
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1126
if(s < 0){
1127
perror_plus("socket");
1128
return false;
1129
}
1130
strcpy(ifr->ifr_name, ifname);
1131
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1132
if(ret == -1){
1133
if(debug){
1134
perror_plus("ioctl SIOCGIFFLAGS");
1135
}
1136
return false;
1137
}
1138
return true;
1139
}
1140
1141
bool good_flags(const char *ifname, const struct ifreq *ifr){
1142
1143
/* Reject the loopback device */
1144
if(ifr->ifr_flags & IFF_LOOPBACK){
1145
if(debug){
1146
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1147
ifname);
1148
}
1149
return false;
1150
}
1151
/* Accept point-to-point devices only if connect_to is specified */
1152
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1153
if(debug){
1154
fprintf_plus(stderr, "Accepting point-to-point interface"
1155
" \"%s\"\n", ifname);
1156
}
1157
return true;
1158
}
1159
/* Otherwise, reject non-broadcast-capable devices */
1160
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1161
if(debug){
1162
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1163
" \"%s\"\n", ifname);
1164
}
1165
return false;
1166
}
1167
/* Reject non-ARP interfaces (including dummy interfaces) */
1168
if(ifr->ifr_flags & IFF_NOARP){
1169
if(debug){
1170
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1171
ifname);
1172
}
1173
return false;
1174
}
1175
1176
/* Accept this device */
1177
if(debug){
1178
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1179
}
1180
return true;
1181
}
1182
1183
/*
1184
* This function determines if a directory entry in /sys/class/net
1185
* corresponds to an acceptable network device.
1186
* (This function is passed to scandir(3) as a filter function.)
1187
*/
1188
int good_interface(const struct dirent *if_entry){
1189
if(if_entry->d_name[0] == '.'){
1190
return 0;
1191
}
1192
1193
struct ifreq ifr;
1194
if(not get_flags(if_entry->d_name, &ifr)){
1195
if(debug){
1196
fprintf_plus(stderr, "Failed to get flags for interface "
1197
"\"%s\"\n", if_entry->d_name);
1198
}
1199
return 0;
1200
}
1201
1202
if(not good_flags(if_entry->d_name, &ifr)){
1203
return 0;
1204
}
1205
return 1;
1206
}
1207
1208
/*
1209
* This function determines if a directory entry in /sys/class/net
1210
* corresponds to an acceptable network device which is up.
1211
* (This function is passed to scandir(3) as a filter function.)
1212
*/
1213
int up_interface(const struct dirent *if_entry){
1214
if(if_entry->d_name[0] == '.'){
1215
return 0;
1216
}
1217
1218
struct ifreq ifr;
1219
if(not get_flags(if_entry->d_name, &ifr)){
1220
if(debug){
1221
fprintf_plus(stderr, "Failed to get flags for interface "
1222
"\"%s\"\n", if_entry->d_name);
1223
}
1224
return 0;
1225
}
1226
1227
/* Reject down interfaces */
1228
if(not (ifr.ifr_flags & IFF_UP)){
1229
if(debug){
1230
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1231
if_entry->d_name);
1232
}
1233
return 0;
1234
}
1235
1236
/* Reject non-running interfaces */
1237
if(not (ifr.ifr_flags & IFF_RUNNING)){
1238
if(debug){
1239
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1240
if_entry->d_name);
1241
}
1242
return 0;
1243
}
1244
1245
if(not good_flags(if_entry->d_name, &ifr)){
1246
return 0;
1247
}
1248
return 1;
1249
}
1250
1251
int notdotentries(const struct dirent *direntry){
1252
/* Skip "." and ".." */
1253
if(direntry->d_name[0] == '.'
1254
and (direntry->d_name[1] == '\0'
1255
or (direntry->d_name[1] == '.'
1256
and direntry->d_name[2] == '\0'))){
1257
return 0;
1258
}
1259
return 1;
1260
}
1261
1262
/* Is this directory entry a runnable program? */
1263
int runnable_hook(const struct dirent *direntry){
1264
int ret;
1265
size_t sret;
1266
struct stat st;
1267
1268
if((direntry->d_name)[0] == '\0'){
1269
/* Empty name? */
1270
return 0;
1271
}
1272
1273
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1274
"abcdefghijklmnopqrstuvwxyz"
1275
"0123456789"
1276
"_-");
1277
if((direntry->d_name)[sret] != '\0'){
1278
/* Contains non-allowed characters */
1279
if(debug){
1280
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1281
direntry->d_name);
1282
}
1283
return 0;
1284
}
1285
1286
char *fullname = NULL;
1287
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1288
if(ret < 0){
1289
perror_plus("asprintf");
1290
return 0;
1291
}
1292
1293
ret = stat(fullname, &st);
1294
if(ret == -1){
1295
if(debug){
1296
perror_plus("Could not stat hook");
1297
}
1298
return 0;
1299
}
1300
if(not (S_ISREG(st.st_mode))){
1301
/* Not a regular file */
1302
if(debug){
1303
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1304
direntry->d_name);
1305
}
1306
return 0;
1307
}
1308
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1309
/* Not executable */
1310
if(debug){
1311
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1312
direntry->d_name);
1313
}
1314
return 0;
1315
}
1316
if(debug){
1317
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1318
direntry->d_name);
1319
}
1320
return 1;
1321
}
1322
1323
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1324
int ret;
1325
struct timespec now;
1326
struct timespec waited_time;
1327
intmax_t block_time;
1328
1329
while(true){
1330
if(mc.current_server == NULL){
1331
if (debug){
1332
fprintf_plus(stderr, "Wait until first server is found."
1333
" No timeout!\n");
1334
}
1335
ret = avahi_simple_poll_iterate(s, -1);
1336
} else {
1337
if (debug){
1338
fprintf_plus(stderr, "Check current_server if we should run"
1339
" it, or wait\n");
1340
}
1341
/* the current time */
1342
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1343
if(ret == -1){
1344
perror_plus("clock_gettime");
1345
return -1;
1346
}
1347
/* Calculating in ms how long time between now and server
1348
who we visted longest time ago. Now - last seen. */
1349
waited_time.tv_sec = (now.tv_sec
1350
- mc.current_server->last_seen.tv_sec);
1351
waited_time.tv_nsec = (now.tv_nsec
1352
- mc.current_server->last_seen.tv_nsec);
1353
/* total time is 10s/10,000ms.
1354
Converting to s from ms by dividing by 1,000,
1355
and ns to ms by dividing by 1,000,000. */
1356
block_time = ((retry_interval
1357
- ((intmax_t)waited_time.tv_sec * 1000))
1358
- ((intmax_t)waited_time.tv_nsec / 1000000));
1359
1360
if (debug){
1361
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1362
block_time);
1363
}
1364
1365
if(block_time <= 0){
1366
ret = start_mandos_communication(mc.current_server->ip,
1367
mc.current_server->port,
1368
mc.current_server->if_index,
1369
mc.current_server->af);
1370
if(ret == 0){
1371
avahi_simple_poll_quit(mc.simple_poll);
1372
return 0;
1373
}
1374
ret = clock_gettime(CLOCK_MONOTONIC,
1375
&mc.current_server->last_seen);
1376
if(ret == -1){
1377
perror_plus("clock_gettime");
1378
return -1;
1379
}
1380
mc.current_server = mc.current_server->next;
1381
block_time = 0; /* Call avahi to find new Mandos
1382
servers, but don't block */
1383
}
1384
1385
ret = avahi_simple_poll_iterate(s, (int)block_time);
1386
}
1387
if(ret != 0){
1388
if (ret > 0 or errno != EINTR){
1389
return (ret != 1) ? ret : 0;
1390
}
1391
}
1392
}
1393
}
1394
1395
/* Set effective uid to 0, return errno */
1396
int raise_privileges(void){
1397
int old_errno = errno;
1398
int ret_errno = 0;
1399
errno = 0;
1400
if(seteuid(0) == -1){
1401
perror_plus("seteuid");
1402
}
1403
ret_errno = errno;
1404
errno = old_errno;
1405
return ret_errno;
1406
}
1407
1408
/* Set effective and real user ID to 0. Return errno. */
1409
int raise_privileges_permanently(void){
1410
int old_errno = errno;
1411
int ret_errno = raise_privileges();
1412
if(ret_errno != 0){
1413
errno = old_errno;
1414
return ret_errno;
1415
}
1416
errno = 0;
1417
if(setuid(0) == -1){
1418
perror_plus("seteuid");
1419
}
1420
ret_errno = errno;
1421
errno = old_errno;
1422
return ret_errno;
1423
}
1424
1425
/* Set effective user ID to unprivileged saved user ID */
1426
int lower_privileges(void){
1427
int old_errno = errno;
1428
int ret_errno = 0;
1429
errno = 0;
1430
if(seteuid(uid) == -1){
1431
perror_plus("seteuid");
1432
}
1433
ret_errno = errno;
1434
errno = old_errno;
1435
return ret_errno;
1436
}
1437
1438
bool run_network_hooks(const char *mode, const char *interface,
1439
const float delay){
1440
struct dirent **direntries;
1441
struct dirent *direntry;
1442
int ret;
1443
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1444
alphasort);
1445
if(numhooks == -1){
1446
perror_plus("scandir");
1447
} else {
1448
int devnull = open("/dev/null", O_RDONLY);
1449
for(int i = 0; i < numhooks; i++){
1450
direntry = direntries[i];
1451
char *fullname = NULL;
1452
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1453
if(ret < 0){
1454
perror_plus("asprintf");
1455
continue;
1456
}
1457
if(debug){
1458
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1459
direntry->d_name);
1460
}
1461
pid_t hook_pid = fork();
1462
if(hook_pid == 0){
1463
/* Child */
1464
/* Raise privileges */
1465
raise_privileges_permanently();
1466
/* Set group */
1467
errno = 0;
1468
ret = setgid(0);
1469
if(ret == -1){
1470
perror_plus("setgid");
1471
}
1472
/* Reset supplementary groups */
1473
errno = 0;
1474
ret = setgroups(0, NULL);
1475
if(ret == -1){
1476
perror_plus("setgroups");
1477
}
1478
dup2(devnull, STDIN_FILENO);
1479
close(devnull);
1480
dup2(STDERR_FILENO, STDOUT_FILENO);
1481
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1482
if(ret == -1){
1483
perror_plus("setenv");
1484
_exit(EX_OSERR);
1485
}
1486
ret = setenv("DEVICE", interface, 1);
1487
if(ret == -1){
1488
perror_plus("setenv");
1489
_exit(EX_OSERR);
1490
}
1491
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1492
if(ret == -1){
1493
perror_plus("setenv");
1494
_exit(EX_OSERR);
1495
}
1496
ret = setenv("MODE", mode, 1);
1497
if(ret == -1){
1498
perror_plus("setenv");
1499
_exit(EX_OSERR);
1500
}
1501
char *delaystring;
1502
ret = asprintf(&delaystring, "%f", delay);
1503
if(ret == -1){
1504
perror_plus("asprintf");
1505
_exit(EX_OSERR);
1506
}
1507
ret = setenv("DELAY", delaystring, 1);
1508
if(ret == -1){
1509
free(delaystring);
1510
perror_plus("setenv");
1511
_exit(EX_OSERR);
1512
}
1513
free(delaystring);
1514
if(connect_to != NULL){
1515
ret = setenv("CONNECT", connect_to, 1);
1516
if(ret == -1){
1517
perror_plus("setenv");
1518
_exit(EX_OSERR);
1519
}
1520
}
1521
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1522
perror_plus("execl");
1523
_exit(EXIT_FAILURE);
1524
}
1525
} else {
1526
int status;
1527
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1528
perror_plus("waitpid");
1529
free(fullname);
1530
continue;
1531
}
1532
if(WIFEXITED(status)){
1533
if(WEXITSTATUS(status) != 0){
1534
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1535
" with status %d\n", direntry->d_name,
1536
WEXITSTATUS(status));
1537
free(fullname);
1538
continue;
1539
}
1540
} else if(WIFSIGNALED(status)){
1541
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1542
" signal %d\n", direntry->d_name,
1543
WTERMSIG(status));
1544
free(fullname);
1545
continue;
1546
} else {
1547
fprintf_plus(stderr, "Warning: network hook \"%s\""
1548
" crashed\n", direntry->d_name);
1549
free(fullname);
1550
continue;
1551
}
1552
}
1553
free(fullname);
1554
if(debug){
1555
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1556
direntry->d_name);
1557
}
1558
}
1559
close(devnull);
1560
}
1561
return true;
1562
}
1563
1564
int bring_up_interface(const char * const interface, const float delay){
1565
int sd = -1;
1566
int old_errno = errno;
1567
int ret_errno = 0;
1568
int ret;
1569
struct ifreq network;
1570
AvahiIfIndex if_index = (AvahiIfIndex)if_nametoindex(interface);
1571
if(if_index == 0){
1572
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1573
errno = old_errno;
1574
return ENXIO;
1575
}
1576
1577
if(quit_now){
1578
errno = old_errno;
1579
return EINTR;
1580
}
1581
1582
/* Re-raise priviliges */
1583
raise_privileges();
1584
1585
#ifdef __linux__
1586
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1587
messages about the network interface to mess up the prompt */
1588
ret = klogctl(8, NULL, 5);
1589
bool restore_loglevel = true;
1590
if(ret == -1){
1591
restore_loglevel = false;
1592
perror_plus("klogctl");
1593
}
1594
#endif /* __linux__ */
1595
1596
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1597
if(sd < 0){
1598
ret_errno = errno;
1599
perror_plus("socket");
1600
#ifdef __linux__
1601
if(restore_loglevel){
1602
ret = klogctl(7, NULL, 0);
1603
if(ret == -1){
1604
perror_plus("klogctl");
1605
}
1606
}
1607
#endif /* __linux__ */
1608
/* Lower privileges */
1609
lower_privileges();
1610
errno = old_errno;
1611
return ret_errno;
1612
}
1613
strcpy(network.ifr_name, interface);
1614
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1615
if(ret == -1){
1616
ret_errno = errno;
1617
perror_plus("ioctl SIOCGIFFLAGS");
1618
#ifdef __linux__
1619
if(restore_loglevel){
1620
ret = klogctl(7, NULL, 0);
1621
if(ret == -1){
1622
perror_plus("klogctl");
1623
}
1624
}
1625
#endif /* __linux__ */
1626
/* Lower privileges */
1627
lower_privileges();
1628
errno = old_errno;
1629
return ret_errno;
1630
}
1631
if((network.ifr_flags & IFF_UP) == 0){
1632
network.ifr_flags |= IFF_UP;
1633
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1634
if(ret == -1){
1635
ret_errno = errno;
1636
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1637
#ifdef __linux__
1638
if(restore_loglevel){
1639
ret = klogctl(7, NULL, 0);
1640
if(ret == -1){
1641
perror_plus("klogctl");
1642
}
1643
}
1644
#endif /* __linux__ */
1645
/* Lower privileges */
1646
lower_privileges();
1647
errno = old_errno;
1648
return ret_errno;
1649
}
1650
}
1651
/* Sleep checking until interface is running.
1652
Check every 0.25s, up to total time of delay */
1653
for(int i=0; i < delay * 4; i++){
1654
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1655
if(ret == -1){
1656
perror_plus("ioctl SIOCGIFFLAGS");
1657
} else if(network.ifr_flags & IFF_RUNNING){
1658
break;
1659
}
1660
struct timespec sleeptime = { .tv_nsec = 250000000 };
1661
ret = nanosleep(&sleeptime, NULL);
1662
if(ret == -1 and errno != EINTR){
1663
perror_plus("nanosleep");
1664
}
1665
}
1666
/* Close the socket */
1667
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1668
if(ret == -1){
1669
perror_plus("close");
1670
}
1671
#ifdef __linux__
1672
if(restore_loglevel){
1673
/* Restores kernel loglevel to default */
1674
ret = klogctl(7, NULL, 0);
1675
if(ret == -1){
1676
perror_plus("klogctl");
1677
}
1678
}
1679
#endif /* __linux__ */
1680
/* Lower privileges */
1681
lower_privileges();
1682
errno = old_errno;
1683
return 0;
1684
}
1685
1686
int main(int argc, char *argv[]){
1687
AvahiSServiceBrowser *sb = NULL;
1688
int error;
1689
int ret;
1690
intmax_t tmpmax;
1691
char *tmp;
1692
int exitcode = EXIT_SUCCESS;
1693
const char *interface = "";
1694
struct ifreq network;
1695
int sd = -1;
1696
bool take_down_interface = false;
1697
char tempdir[] = "/tmp/mandosXXXXXX";
1698
bool tempdir_created = false;
1699
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1700
const char *seckey = PATHDIR "/" SECKEY;
1701
const char *pubkey = PATHDIR "/" PUBKEY;
1702
1703
bool gnutls_initialized = false;
1704
bool gpgme_initialized = false;
1705
float delay = 2.5f;
1706
double retry_interval = 10; /* 10s between trying a server and
1707
retrying the same server again */
1708
1709
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1710
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1711
1712
uid = getuid();
1713
gid = getgid();
1714
1715
/* Lower any group privileges we might have, just to be safe */
1716
errno = 0;
1717
ret = setgid(gid);
1718
if(ret == -1){
1719
perror_plus("setgid");
1720
}
1721
1722
/* Lower user privileges (temporarily) */
1723
errno = 0;
1724
ret = seteuid(uid);
1725
if(ret == -1){
1726
perror_plus("seteuid");
1727
}
1728
1729
if(quit_now){
1730
goto end;
1731
}
1732
1733
{
1734
struct argp_option options[] = {
1735
{ .name = "debug", .key = 128,
1736
.doc = "Debug mode", .group = 3 },
1737
{ .name = "connect", .key = 'c',
1738
.arg = "ADDRESS:PORT",
1739
.doc = "Connect directly to a specific Mandos server",
1740
.group = 1 },
1741
{ .name = "interface", .key = 'i',
1742
.arg = "NAME",
1743
.doc = "Network interface that will be used to search for"
1744
" Mandos servers",
1745
.group = 1 },
1746
{ .name = "seckey", .key = 's',
1747
.arg = "FILE",
1748
.doc = "OpenPGP secret key file base name",
1749
.group = 1 },
1750
{ .name = "pubkey", .key = 'p',
1751
.arg = "FILE",
1752
.doc = "OpenPGP public key file base name",
1753
.group = 2 },
1754
{ .name = "dh-bits", .key = 129,
1755
.arg = "BITS",
1756
.doc = "Bit length of the prime number used in the"
1757
" Diffie-Hellman key exchange",
1758
.group = 2 },
1759
{ .name = "priority", .key = 130,
1760
.arg = "STRING",
1761
.doc = "GnuTLS priority string for the TLS handshake",
1762
.group = 1 },
1763
{ .name = "delay", .key = 131,
1764
.arg = "SECONDS",
1765
.doc = "Maximum delay to wait for interface startup",
1766
.group = 2 },
1767
{ .name = "retry", .key = 132,
1768
.arg = "SECONDS",
1769
.doc = "Retry interval used when denied by the Mandos server",
1770
.group = 2 },
1771
{ .name = "network-hook-dir", .key = 133,
1772
.arg = "DIR",
1773
.doc = "Directory where network hooks are located",
1774
.group = 2 },
1775
/*
1776
* These reproduce what we would get without ARGP_NO_HELP
1777
*/
1778
{ .name = "help", .key = '?',
1779
.doc = "Give this help list", .group = -1 },
1780
{ .name = "usage", .key = -3,
1781
.doc = "Give a short usage message", .group = -1 },
1782
{ .name = "version", .key = 'V',
1783
.doc = "Print program version", .group = -1 },
1784
{ .name = NULL }
1785
};
1786
1787
error_t parse_opt(int key, char *arg,
1788
struct argp_state *state){
1789
errno = 0;
1790
switch(key){
1791
case 128: /* --debug */
1792
debug = true;
1793
break;
1794
case 'c': /* --connect */
1795
connect_to = arg;
1796
break;
1797
case 'i': /* --interface */
1798
interface = arg;
1799
break;
1800
case 's': /* --seckey */
1801
seckey = arg;
1802
break;
1803
case 'p': /* --pubkey */
1804
pubkey = arg;
1805
break;
1806
case 129: /* --dh-bits */
1807
errno = 0;
1808
tmpmax = strtoimax(arg, &tmp, 10);
1809
if(errno != 0 or tmp == arg or *tmp != '\0'
1810
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1811
argp_error(state, "Bad number of DH bits");
1812
}
1813
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1814
break;
1815
case 130: /* --priority */
1816
mc.priority = arg;
1817
break;
1818
case 131: /* --delay */
1819
errno = 0;
1820
delay = strtof(arg, &tmp);
1821
if(errno != 0 or tmp == arg or *tmp != '\0'){
1822
argp_error(state, "Bad delay");
1823
}
1824
case 132: /* --retry */
1825
errno = 0;
1826
retry_interval = strtod(arg, &tmp);
1827
if(errno != 0 or tmp == arg or *tmp != '\0'
1828
or (retry_interval * 1000) > INT_MAX
1829
or retry_interval < 0){
1830
argp_error(state, "Bad retry interval");
1831
}
1832
break;
1833
case 133: /* --network-hook-dir */
1834
hookdir = arg;
1835
break;
1836
/*
1837
* These reproduce what we would get without ARGP_NO_HELP
1838
*/
1839
case '?': /* --help */
1840
argp_state_help(state, state->out_stream,
1841
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1842
& ~(unsigned int)ARGP_HELP_EXIT_OK);
1843
case -3: /* --usage */
1844
argp_state_help(state, state->out_stream,
1845
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1846
case 'V': /* --version */
1847
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1848
exit(argp_err_exit_status);
1849
break;
1850
default:
1851
return ARGP_ERR_UNKNOWN;
1852
}
1853
return errno;
1854
}
1855
1856
struct argp argp = { .options = options, .parser = parse_opt,
1857
.args_doc = "",
1858
.doc = "Mandos client -- Get and decrypt"
1859
" passwords from a Mandos server" };
1860
ret = argp_parse(&argp, argc, argv,
1861
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1862
switch(ret){
1863
case 0:
1864
break;
1865
case ENOMEM:
587
1866
default:
588
case AVAHI_BROWSER_FAILURE:
589
590
fprintf(stderr, "(Browser) %s\n",
591
avahi_strerror(avahi_server_errno(server)));
592
avahi_simple_poll_quit(simple_poll);
593
return;
594
595
case AVAHI_BROWSER_NEW:
596
/* We ignore the returned resolver object. In the callback
597
function we free it. If the server is terminated before
598
the callback function is called the server will free
599
the resolver for us. */
600
601
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
602
type, domain,
603
AVAHI_PROTO_INET6, 0,
604
resolve_callback, s)))
605
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
606
avahi_strerror(avahi_server_errno(s)));
607
break;
608
609
case AVAHI_BROWSER_REMOVE:
610
break;
611
612
case AVAHI_BROWSER_ALL_FOR_NOW:
613
case AVAHI_BROWSER_CACHE_EXHAUSTED:
614
break;
615
}
616
}
617
618
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
1867
errno = ret;
1868
perror_plus("argp_parse");
1869
exitcode = EX_OSERR;
1870
goto end;
1871
case EINVAL:
1872
exitcode = EX_USAGE;
1873
goto end;
1874
}
1875
}
1876
1877
{
1878
/* Work around Debian bug #633582:
1879
<http://bugs.debian.org/633582> */
1880
1881
/* Re-raise priviliges */
1882
if(raise_privileges() == 0){
1883
struct stat st;
1884
1885
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1886
int seckey_fd = open(seckey, O_RDONLY);
1887
if(seckey_fd == -1){
1888
perror_plus("open");
1889
} else {
1890
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1891
if(ret == -1){
1892
perror_plus("fstat");
1893
} else {
1894
if(S_ISREG(st.st_mode)
1895
and st.st_uid == 0 and st.st_gid == 0){
1896
ret = fchown(seckey_fd, uid, gid);
1897
if(ret == -1){
1898
perror_plus("fchown");
1899
}
1900
}
1901
}
1902
TEMP_FAILURE_RETRY(close(seckey_fd));
1903
}
1904
}
1905
1906
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1907
int pubkey_fd = open(pubkey, O_RDONLY);
1908
if(pubkey_fd == -1){
1909
perror_plus("open");
1910
} else {
1911
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1912
if(ret == -1){
1913
perror_plus("fstat");
1914
} else {
1915
if(S_ISREG(st.st_mode)
1916
and st.st_uid == 0 and st.st_gid == 0){
1917
ret = fchown(pubkey_fd, uid, gid);
1918
if(ret == -1){
1919
perror_plus("fchown");
1920
}
1921
}
1922
}
1923
TEMP_FAILURE_RETRY(close(pubkey_fd));
1924
}
1925
}
1926
1927
/* Lower privileges */
1928
errno = 0;
1929
ret = seteuid(uid);
1930
if(ret == -1){
1931
perror_plus("seteuid");
1932
}
1933
}
1934
}
1935
1936
/* Run network hooks */
1937
if(not run_network_hooks("start", interface, delay)){
1938
goto end;
1939
}
1940
1941
if(not debug){
1942
avahi_set_log_function(empty_log);
1943
}
1944
1945
if(interface[0] == '\0'){
1946
struct dirent **direntries;
1947
/* First look for interfaces that are up */
1948
ret = scandir(sys_class_net, &direntries, up_interface,
1949
alphasort);
1950
if(ret == 0){
1951
/* No up interfaces, look for any good interfaces */
1952
free(direntries);
1953
ret = scandir(sys_class_net, &direntries, good_interface,
1954
alphasort);
1955
}
1956
if(ret >= 1){
1957
/* Pick the first interface returned */
1958
interface = strdup(direntries[0]->d_name);
1959
if(debug){
1960
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1961
}
1962
if(interface == NULL){
1963
perror_plus("malloc");
1964
free(direntries);
1965
exitcode = EXIT_FAILURE;
1966
goto end;
1967
}
1968
free(direntries);
1969
} else {
1970
free(direntries);
1971
fprintf_plus(stderr, "Could not find a network interface\n");
1972
exitcode = EXIT_FAILURE;
1973
goto end;
1974
}
1975
}
1976
1977
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1978
from the signal handler */
1979
/* Initialize the pseudo-RNG for Avahi */
1980
srand((unsigned int) time(NULL));
1981
mc.simple_poll = avahi_simple_poll_new();
1982
if(mc.simple_poll == NULL){
1983
fprintf_plus(stderr,
1984
"Avahi: Failed to create simple poll object.\n");
1985
exitcode = EX_UNAVAILABLE;
1986
goto end;
1987
}
1988
1989
sigemptyset(&sigterm_action.sa_mask);
1990
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1991
if(ret == -1){
1992
perror_plus("sigaddset");
1993
exitcode = EX_OSERR;
1994
goto end;
1995
}
1996
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1997
if(ret == -1){
1998
perror_plus("sigaddset");
1999
exitcode = EX_OSERR;
2000
goto end;
2001
}
2002
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2003
if(ret == -1){
2004
perror_plus("sigaddset");
2005
exitcode = EX_OSERR;
2006
goto end;
2007
}
2008
/* Need to check if the handler is SIG_IGN before handling:
2009
| [[info:libc:Initial Signal Actions]] |
2010
| [[info:libc:Basic Signal Handling]] |
2011
*/
2012
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2013
if(ret == -1){
2014
perror_plus("sigaction");
2015
return EX_OSERR;
2016
}
2017
if(old_sigterm_action.sa_handler != SIG_IGN){
2018
ret = sigaction(SIGINT, &sigterm_action, NULL);
2019
if(ret == -1){
2020
perror_plus("sigaction");
2021
exitcode = EX_OSERR;
2022
goto end;
2023
}
2024
}
2025
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2026
if(ret == -1){
2027
perror_plus("sigaction");
2028
return EX_OSERR;
2029
}
2030
if(old_sigterm_action.sa_handler != SIG_IGN){
2031
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2032
if(ret == -1){
2033
perror_plus("sigaction");
2034
exitcode = EX_OSERR;
2035
goto end;
2036
}
2037
}
2038
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2039
if(ret == -1){
2040
perror_plus("sigaction");
2041
return EX_OSERR;
2042
}
2043
if(old_sigterm_action.sa_handler != SIG_IGN){
2044
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2045
if(ret == -1){
2046
perror_plus("sigaction");
2047
exitcode = EX_OSERR;
2048
goto end;
2049
}
2050
}
2051
2052
/* If the interface is down, bring it up */
2053
if((interface[0] != '\0') and (strcmp(interface, "none") != 0)){
2054
ret = bring_up_interface(interface, delay);
2055
if(ret != 0){
2056
errno = ret;
2057
perror_plus("Failed to bring up interface");
2058
}
2059
}
2060
2061
if(quit_now){
2062
goto end;
2063
}
2064
2065
ret = init_gnutls_global(pubkey, seckey);
2066
if(ret == -1){
2067
fprintf_plus(stderr, "init_gnutls_global failed\n");
2068
exitcode = EX_UNAVAILABLE;
2069
goto end;
2070
} else {
2071
gnutls_initialized = true;
2072
}
2073
2074
if(quit_now){
2075
goto end;
2076
}
2077
2078
if(mkdtemp(tempdir) == NULL){
2079
perror_plus("mkdtemp");
2080
goto end;
2081
}
2082
tempdir_created = true;
2083
2084
if(quit_now){
2085
goto end;
2086
}
2087
2088
if(not init_gpgme(pubkey, seckey, tempdir)){
2089
fprintf_plus(stderr, "init_gpgme failed\n");
2090
exitcode = EX_UNAVAILABLE;
2091
goto end;
2092
} else {
2093
gpgme_initialized = true;
2094
}
2095
2096
if(quit_now){
2097
goto end;
2098
}
2099
2100
if(connect_to != NULL){
2101
/* Connect directly, do not use Zeroconf */
2102
/* (Mainly meant for debugging) */
2103
char *address = strrchr(connect_to, ':');
2104
2105
if(address == NULL){
2106
fprintf_plus(stderr, "No colon in address\n");
2107
exitcode = EX_USAGE;
2108
goto end;
2109
}
2110
2111
if(quit_now){
2112
goto end;
2113
}
2114
2115
uint16_t port;
2116
errno = 0;
2117
tmpmax = strtoimax(address+1, &tmp, 10);
2118
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2119
or tmpmax != (uint16_t)tmpmax){
2120
fprintf_plus(stderr, "Bad port number\n");
2121
exitcode = EX_USAGE;
2122
goto end;
2123
}
2124
2125
if(quit_now){
2126
goto end;
2127
}
2128
2129
port = (uint16_t)tmpmax;
2130
*address = '\0';
2131
/* Colon in address indicates IPv6 */
2132
int af;
2133
if(strchr(connect_to, ':') != NULL){
2134
af = AF_INET6;
2135
/* Accept [] around IPv6 address - see RFC 5952 */
2136
if(connect_to[0] == '[' and address[-1] == ']')
2137
{
2138
connect_to++;
2139
address[-1] = '\0';
2140
}
2141
} else {
2142
af = AF_INET;
2143
}
2144
address = connect_to;
2145
2146
if(quit_now){
2147
goto end;
2148
}
2149
2150
while(not quit_now){
2151
ret = start_mandos_communication(address, port, if_index, af);
2152
if(quit_now or ret == 0){
2153
break;
2154
}
2155
if(debug){
2156
fprintf_plus(stderr, "Retrying in %d seconds\n",
2157
(int)retry_interval);
2158
}
2159
sleep((int)retry_interval);
2160
}
2161
2162
if (not quit_now){
2163
exitcode = EXIT_SUCCESS;
2164
}
2165
2166
goto end;
2167
}
2168
2169
if(quit_now){
2170
goto end;
2171
}
2172
2173
{
619
2174
AvahiServerConfig config;
620
AvahiSServiceBrowser *sb = NULL;
621
int error;
622
int ret;
623
int returncode = EXIT_SUCCESS;
624
const char *interface = "eth0";
625
626
while (true){
627
static struct option long_options[] = {
628
{"debug", no_argument, (int *)&debug, 1},
629
{"interface", required_argument, 0, 'i'},
630
{0, 0, 0, 0} };
631
632
int option_index = 0;
633
ret = getopt_long (argc, argv, "i:", long_options,
634
&option_index);
635
636
if (ret == -1){
637
break;
638
}
639
640
switch(ret){
641
case 0:
642
break;
643
case 'i':
644
interface = optarg;
645
break;
646
default:
647
exit(EXIT_FAILURE);
648
}
649
}
650
651
if (not debug){
652
avahi_set_log_function(empty_log);
653
}
654
655
/* Initialize the psuedo-RNG */
656
srand((unsigned int) time(NULL));
657
658
/* Allocate main loop object */
659
if (!(simple_poll = avahi_simple_poll_new())) {
660
fprintf(stderr, "Failed to create simple poll object.\n");
661
662
goto exit;
663
}
664
665
/* Do not publish any local records */
2175
/* Do not publish any local Zeroconf records */
666
2176
avahi_server_config_init(&config);
667
2177
config.publish_hinfo = 0;
668
2178
config.publish_addresses = 0;
669
2179
config.publish_workstation = 0;
670
2180
config.publish_domain = 0;
671
2181
672
2182
/* Allocate a new server */
673
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
674
&config, NULL, NULL, &error);
675
676
/* Free the configuration data */
2183
mc.server = avahi_server_new(avahi_simple_poll_get
2184
(mc.simple_poll), &config, NULL,
2185
NULL, &error);
2186
2187
/* Free the Avahi configuration data */
677
2188
avahi_server_config_free(&config);
678
679
/* Check if creating the server object succeeded */
680
if (!server) {
681
fprintf(stderr, "Failed to create server: %s\n",
682
avahi_strerror(error));
683
returncode = EXIT_FAILURE;
684
goto exit;
685
}
686
687
/* Create the service browser */
688
sb = avahi_s_service_browser_new(server,
689
(AvahiIfIndex)
690
if_nametoindex(interface),
691
AVAHI_PROTO_INET6,
692
"_mandos._tcp", NULL, 0,
693
browse_callback, server);
694
if (!sb) {
695
fprintf(stderr, "Failed to create service browser: %s\n",
696
avahi_strerror(avahi_server_errno(server)));
697
returncode = EXIT_FAILURE;
698
goto exit;
699
}
700
701
/* Run the main loop */
702
703
if (debug){
704
fprintf(stderr, "Starting avahi loop search\n");
705
}
706
707
avahi_simple_poll_loop(simple_poll);
708
709
exit:
710
711
if (debug){
712
fprintf(stderr, "%s exiting\n", argv[0]);
713
}
714
715
/* Cleanup things */
716
if (sb)
717
avahi_s_service_browser_free(sb);
718
719
if (server)
720
avahi_server_free(server);
721
722
if (simple_poll)
723
avahi_simple_poll_free(simple_poll);
724
725
return returncode;
2189
}
2190
2191
/* Check if creating the Avahi server object succeeded */
2192
if(mc.server == NULL){
2193
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2194
avahi_strerror(error));
2195
exitcode = EX_UNAVAILABLE;
2196
goto end;
2197
}
2198
2199
if(quit_now){
2200
goto end;
2201
}
2202
2203
/* Create the Avahi service browser */
2204
sb = avahi_s_service_browser_new(mc.server, if_index,
2205
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2206
NULL, 0, browse_callback, NULL);
2207
if(sb == NULL){
2208
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2209
avahi_strerror(avahi_server_errno(mc.server)));
2210
exitcode = EX_UNAVAILABLE;
2211
goto end;
2212
}
2213
2214
if(quit_now){
2215
goto end;
2216
}
2217
2218
/* Run the main loop */
2219
2220
if(debug){
2221
fprintf_plus(stderr, "Starting Avahi loop search\n");
2222
}
2223
2224
ret = avahi_loop_with_timeout(mc.simple_poll,
2225
(int)(retry_interval * 1000));
2226
if(debug){
2227
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2228
(ret == 0) ? "successfully" : "with error");
2229
}
2230
2231
end:
2232
2233
if(debug){
2234
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2235
}
2236
2237
/* Cleanup things */
2238
if(sb != NULL)
2239
avahi_s_service_browser_free(sb);
2240
2241
if(mc.server != NULL)
2242
avahi_server_free(mc.server);
2243
2244
if(mc.simple_poll != NULL)
2245
avahi_simple_poll_free(mc.simple_poll);
2246
2247
if(gnutls_initialized){
2248
gnutls_certificate_free_credentials(mc.cred);
2249
gnutls_global_deinit();
2250
gnutls_dh_params_deinit(mc.dh_params);
2251
}
2252
2253
if(gpgme_initialized){
2254
gpgme_release(mc.ctx);
2255
}
2256
2257
/* Cleans up the circular linked list of Mandos servers the client
2258
has seen */
2259
if(mc.current_server != NULL){
2260
mc.current_server->prev->next = NULL;
2261
while(mc.current_server != NULL){
2262
server *next = mc.current_server->next;
2263
free(mc.current_server);
2264
mc.current_server = next;
2265
}
2266
}
2267
2268
/* Run network hooks */
2269
run_network_hooks("stop", interface, delay);
2270
2271
/* Re-raise priviliges */
2272
{
2273
raise_privileges();
2274
2275
/* Take down the network interface */
2276
if(take_down_interface and geteuid() == 0){
2277
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2278
if(ret == -1){
2279
perror_plus("ioctl SIOCGIFFLAGS");
2280
} else if(network.ifr_flags & IFF_UP){
2281
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2282
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2283
if(ret == -1){
2284
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2285
}
2286
}
2287
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2288
if(ret == -1){
2289
perror_plus("close");
2290
}
2291
}
2292
}
2293
/* Lower privileges permanently */
2294
errno = 0;
2295
ret = setuid(uid);
2296
if(ret == -1){
2297
perror_plus("setuid");
2298
}
2299
2300
/* Removes the GPGME temp directory and all files inside */
2301
if(tempdir_created){
2302
struct dirent **direntries = NULL;
2303
struct dirent *direntry = NULL;
2304
int numentries = scandir(tempdir, &direntries, notdotentries,
2305
alphasort);
2306
if (numentries > 0){
2307
for(int i = 0; i < numentries; i++){
2308
direntry = direntries[i];
2309
char *fullname = NULL;
2310
ret = asprintf(&fullname, "%s/%s", tempdir,
2311
direntry->d_name);
2312
if(ret < 0){
2313
perror_plus("asprintf");
2314
continue;
2315
}
2316
ret = remove(fullname);
2317
if(ret == -1){
2318
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2319
strerror(errno));
2320
}
2321
free(fullname);
2322
}
2323
}
2324
2325
/* need to clean even if 0 because man page doesn't specify */
2326
free(direntries);
2327
if (numentries == -1){
2328
perror_plus("scandir");
2329
}
2330
ret = rmdir(tempdir);
2331
if(ret == -1 and errno != ENOENT){
2332
perror_plus("rmdir");
2333
}
2334
}
2335
2336
if(quit_now){
2337
sigemptyset(&old_sigterm_action.sa_mask);
2338
old_sigterm_action.sa_handler = SIG_DFL;
2339
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2340
&old_sigterm_action,
2341
NULL));
2342
if(ret == -1){
2343
perror_plus("sigaction");
2344
}
2345
do {
2346
ret = raise(signal_received);
2347
} while(ret != 0 and errno == EINTR);
2348
if(ret != 0){
2349
perror_plus("raise");
2350
abort();
2351
}
2352
TEMP_FAILURE_RETRY(pause());
2353
}
2354
2355
return exitcode;
726
2356
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0