dtls.c 19.3 KB
Newer Older
venaas's avatar
venaas committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
 * Copyright (C) 2008 Stig Venaas <venaas@uninett.no>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 */

#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#ifdef SYS_SOLARIS9
#include <fcntl.h>
#endif
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>
#include <ctype.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <regex.h>
#include <pthread.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include "debug.h"
#include "list.h"
31
#include "hash.h"
venaas's avatar
venaas committed
32
33
#include "util.h"
#include "radsecproxy.h"
venaas's avatar
venaas committed
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

void *udpdtlsserverrd(void *arg);
int dtlsconnect(struct server *server, struct timeval *when, int timeout, char *text);
void *dtlsclientrd(void *arg);
int clientradputdtls(struct server *server, unsigned char *rad);
void addserverextradtls(struct clsrvconf *conf);
void dtlssetsrcres(char *source);
void initextradtls();

static const struct protodefs protodefs = {
    "dtls",
    "mysecret", /* secretdefault */
    SOCK_DGRAM, /* socktype */
    "2083", /* portdefault */
    REQUEST_RETRY_COUNT, /* retrycountdefault */
    10, /* retrycountmax */
    REQUEST_RETRY_INTERVAL, /* retryintervaldefault */
    60, /* retryintervalmax */
    DUPLICATE_INTERVAL, /* duplicateintervaldefault */
    udpdtlsserverrd, /* listener */
    dtlsconnect, /* connecter */
    dtlsclientrd, /* clientconnreader */
    clientradputdtls, /* clientradput */
    NULL, /* addclient */
    addserverextradtls, /* addserverextra */
    dtlssetsrcres, /* setsrcres */
    initextradtls /* initextra */
};
venaas's avatar
venaas committed
62

venaas's avatar
venaas committed
63
64
static int client4_sock = -1;
static int client6_sock = -1;
venaas's avatar
venaas committed
65
static struct addrinfo *srcres = NULL;
venaas's avatar
venaas committed
66
67
68
69
70
71
static uint8_t handle;

const struct protodefs *dtlsinit(uint8_t h) {
    handle = h;
    return &protodefs;
}
venaas's avatar
venaas committed
72

73
74
75
76
77
78
79
80
81
82
83
84
struct sessioncacheentry {
    pthread_mutex_t mutex;
    struct queue *rbios;
    struct timeval expiry;
};

struct dtlsservernewparams {
    struct sessioncacheentry *sesscache;
    int sock;
    struct sockaddr_storage addr;    
};

venaas's avatar
venaas committed
85
86
void dtlssetsrcres(char *source) {
    if (!srcres)
venaas's avatar
venaas committed
87
	srcres = resolve_hostport_addrinfo(handle, source);
venaas's avatar
venaas committed
88
89
}

venaas's avatar
venaas committed
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
int udp2bio(int s, struct queue *q, int cnt) {
    unsigned char *buf;
    BIO *rbio;

    if (cnt < 1)
	return 0;
    
    buf = malloc(cnt);
    if (!buf) {
	unsigned char err;
	debug(DBG_ERR, "udp2bio: malloc failed");
	recv(s, &err, 1, 0);
	return 0;
    }

    cnt = recv(s, buf, cnt, 0);
    if (cnt < 1) {
	debug(DBG_WARN, "udp2bio: recv failed");
	free(buf);
	return 0;
    }

    rbio = BIO_new_mem_buf(buf, cnt);
    BIO_set_mem_eof_return(rbio, -1);

    pthread_mutex_lock(&q->mutex);
    if (!list_push(q->entries, rbio)) {
	BIO_free(rbio);
	pthread_mutex_unlock(&q->mutex);
	return 0;
    }
    pthread_cond_signal(&q->cond);
    pthread_mutex_unlock(&q->mutex);
    return 1;
}

BIO *getrbio(SSL *ssl, struct queue *q, int timeout) {
    BIO *rbio;
    struct timeval now;
    struct timespec to;

    pthread_mutex_lock(&q->mutex);
    if (!(rbio = (BIO *)list_shift(q->entries))) {
	if (timeout) {
	    gettimeofday(&now, NULL);
	    memset(&to, 0, sizeof(struct timespec));
	    to.tv_sec = now.tv_sec + timeout;
	    pthread_cond_timedwait(&q->cond, &q->mutex, &to);
	} else
	    pthread_cond_wait(&q->cond, &q->mutex);
	rbio = (BIO *)list_shift(q->entries);
    }
    pthread_mutex_unlock(&q->mutex);
    return rbio;
}

146
int dtlsread(SSL *ssl, struct queue *q, unsigned char *buf, int num, int timeout) {
venaas's avatar
venaas committed
147
    int len, cnt;
148
149
    BIO *rbio;
    
venaas's avatar
venaas committed
150
151
152
153
154
    for (len = 0; len < num; len += cnt) {
	cnt = SSL_read(ssl, buf + len, num - len);
	if (cnt <= 0)
	    switch (cnt = SSL_get_error(ssl, cnt)) {
	    case SSL_ERROR_WANT_READ:
155
156
157
		rbio = getrbio(ssl, q, timeout);
		if (!rbio)
		    return 0;
venaas's avatar
venaas committed
158
		BIO_free(ssl->rbio);		
159
		ssl->rbio = rbio;
venaas's avatar
venaas committed
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
		cnt = 0;
		continue;
	    case SSL_ERROR_WANT_WRITE:
		cnt = 0;
		continue;
	    case SSL_ERROR_ZERO_RETURN:
		/* remote end sent close_notify, send one back */
		SSL_shutdown(ssl);
		return -1;
	    default:
		return -1;
	    }
    }
    return num;
}

176
177
178
179
180
181
182
183
184
185
186
187
188
189
/* accept if acc == 1, else connect */
SSL *dtlsacccon(uint8_t acc, SSL_CTX *ctx, int s, struct sockaddr *addr, struct queue *rbios) {
    SSL *ssl;
    int i, res;
    unsigned long error;
    BIO *mem0bio, *wbio;

    ssl = SSL_new(ctx);
    if (!ssl)
	return NULL;
    
    mem0bio = BIO_new(BIO_s_mem());
    BIO_set_mem_eof_return(mem0bio, -1);
    wbio = BIO_new_dgram(s, BIO_NOCLOSE);
190
    i = BIO_dgram_set_peer(wbio, addr); /* i just to avoid warning */
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
    SSL_set_bio(ssl, mem0bio, wbio);

    for (i = 0; i < 5; i++) {
        res = acc ? SSL_accept(ssl) : SSL_connect(ssl);
        if (res > 0)
            return ssl;
        if (res == 0)
            break;
        if (SSL_get_error(ssl, res) == SSL_ERROR_WANT_READ) {
            BIO_free(ssl->rbio);
            ssl->rbio = getrbio(ssl, rbios, 5);
            if (!ssl->rbio)
                break;
        }
        while ((error = ERR_get_error()))
            debug(DBG_ERR, "dtls%st: DTLS: %s", acc ? "accep" : "connec", ERR_error_string(error, NULL));
    }

    SSL_free(ssl);
    return NULL;
}

unsigned char *raddtlsget(SSL *ssl, struct queue *rbios, int timeout) {
venaas's avatar
venaas committed
214
215
216
217
    int cnt, len;
    unsigned char buf[4], *rad;

    for (;;) {
218
        cnt = dtlsread(ssl, rbios, buf, 4, timeout);
venaas's avatar
venaas committed
219
        if (cnt < 1) {
220
            debug(DBG_DBG, cnt ? "raddtlsget: connection lost" : "raddtlsget: timeout");
venaas's avatar
venaas committed
221
222
223
224
225
226
227
228
229
230
231
            return NULL;
        }

	len = RADLEN(buf);
	rad = malloc(len);
	if (!rad) {
	    debug(DBG_ERR, "raddtlsget: malloc failed");
	    continue;
	}
	memcpy(rad, buf, 4);
	
232
	cnt = dtlsread(ssl, rbios, rad + 4, len - 4, timeout);
venaas's avatar
venaas committed
233
        if (cnt < 1) {
234
            debug(DBG_DBG, cnt ? "raddtlsget: connection lost" : "raddtlsget: timeout");
venaas's avatar
venaas committed
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
            free(rad);
            return NULL;
        }
        
        if (len >= 20)
            break;
	
        free(rad);
        debug(DBG_WARN, "raddtlsget: packet smaller than minimum radius size");
    }
    
    debug(DBG_DBG, "raddtlsget: got %d bytes", len);
    return rad;
}

250
251
252
253
254
void *dtlsserverwr(void *arg) {
    int cnt;
    unsigned long error;
    struct client *client = (struct client *)arg;
    struct queue *replyq;
venaas's avatar
venaas committed
255
    struct request *reply;
256
    
257
    debug(DBG_DBG, "dtlsserverwr: starting for %s", addr2string(client->addr));
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
    replyq = client->replyq;
    for (;;) {
	pthread_mutex_lock(&replyq->mutex);
	while (!list_first(replyq->entries)) {
	    if (client->ssl) {	    
		debug(DBG_DBG, "dtlsserverwr: waiting for signal");
		pthread_cond_wait(&replyq->cond, &replyq->mutex);
		debug(DBG_DBG, "dtlsserverwr: got signal");
	    }
	    if (!client->ssl) {
		/* ssl might have changed while waiting */
		pthread_mutex_unlock(&replyq->mutex);
		debug(DBG_DBG, "dtlsserverwr: exiting as requested");
		ERR_remove_state(0);
		pthread_exit(NULL);
	    }
	}
venaas's avatar
venaas committed
275
	reply = (struct request *)list_shift(replyq->entries);
276
	pthread_mutex_unlock(&replyq->mutex);
venaas's avatar
venaas committed
277
	cnt = SSL_write(client->ssl, reply->replybuf, RADLEN(reply->replybuf));
278
	if (cnt > 0)
279
280
	    debug(DBG_DBG, "dtlsserverwr: sent %d bytes, Radius packet of length %d to %s",
		  cnt, RADLEN(reply->replybuf), addr2string(client->addr));
281
282
283
	else
	    while ((error = ERR_get_error()))
		debug(DBG_ERR, "dtlsserverwr: SSL: %s", ERR_error_string(error, NULL));
venaas's avatar
venaas committed
284
	freerq(reply);
285
286
287
    }
}

venaas's avatar
venaas committed
288
void dtlsserverrd(struct client *client) {
289
290
    struct request *rq;
    uint8_t *buf;
venaas's avatar
venaas committed
291
292
    pthread_t dtlsserverwrth;
    
293
    debug(DBG_DBG, "dtlsserverrd: starting for %s", addr2string(client->addr));
venaas's avatar
venaas committed
294
295
296
297
298
299
300

    if (pthread_create(&dtlsserverwrth, NULL, dtlsserverwr, (void *)client)) {
	debug(DBG_ERR, "dtlsserverrd: pthread_create failed");
	return;
    }

    for (;;) {
301
302
	buf = raddtlsget(client->ssl, client->rbios, IDLE_TIMEOUT);
	if (!buf) {
303
	    debug(DBG_ERR, "dtlsserverrd: connection from %s lost", addr2string(client->addr));
venaas's avatar
venaas committed
304
305
	    break;
	}
306
	debug(DBG_DBG, "dtlsserverrd: got Radius message from %s", addr2string(client->addr));
307
308
309
310
311
312
313
314
	rq = newrequest();
	if (!rq) {
	    free(buf);
	    continue;
	}
	rq->buf = buf;
	rq->from = client;
	if (!radsrv(rq)) {
315
	    debug(DBG_ERR, "dtlsserverrd: message authentication/validation failed, closing connection from %s", addr2string(client->addr));
venaas's avatar
venaas committed
316
317
318
319
320
321
322
323
324
325
326
327
	    break;
	}
    }
    
    /* stop writer by setting ssl to NULL and give signal in case waiting for data */
    client->ssl = NULL;

    pthread_mutex_lock(&client->replyq->mutex);
    pthread_cond_signal(&client->replyq->cond);
    pthread_mutex_unlock(&client->replyq->mutex);
    debug(DBG_DBG, "dtlsserverrd: waiting for writer to end");
    pthread_join(dtlsserverwrth, NULL);
328
    debug(DBG_DBG, "dtlsserverrd: reader for %s exiting", addr2string(client->addr));
venaas's avatar
venaas committed
329
330
331
}

void *dtlsservernew(void *arg) {
332
333
    struct dtlsservernewparams *params = (struct dtlsservernewparams *)arg;
    struct client *client;
334
335
336
    struct clsrvconf *conf;
    struct list_node *cur = NULL;
    SSL *ssl = NULL;
venaas's avatar
venaas committed
337
    X509 *cert = NULL;
338
    SSL_CTX *ctx = NULL;
339
340
341
    uint8_t delay = 60;

    debug(DBG_DBG, "dtlsservernew: starting");
venaas's avatar
venaas committed
342
    conf = find_clconf(handle, (struct sockaddr *)&params->addr, NULL);
343
    if (conf) {
venaas's avatar
venaas committed
344
	ctx = tlsgetctx(handle, conf->tlsconf);
345
346
347
	if (!ctx)
	    goto exit;
	ssl = dtlsacccon(1, ctx, params->sock, (struct sockaddr *)&params->addr, params->sesscache->rbios);
348
349
350
351
352
353
354
355
356
357
	if (!ssl)
	    goto exit;
	cert = verifytlscert(ssl);
        if (!cert)
            goto exit;
    }

    while (conf) {
	if (verifyconfcert(cert, conf)) {
	    X509_free(cert);
358
	    client = addclient(conf, 1);
359
	    if (client) {
360
		client->sock = params->sock;
361
		client->addr = addr_copy((struct sockaddr *)&params->addr);
362
		client->rbios = params->sesscache->rbios;
363
364
365
		client->ssl = ssl;
		dtlsserverrd(client);
		removeclient(client);
366
		delay = 0;
367
368
369
370
371
	    } else {
		debug(DBG_WARN, "dtlsservernew: failed to create new client instance");
	    }
	    goto exit;
	}
venaas's avatar
venaas committed
372
	conf = find_clconf(handle, (struct sockaddr *)&params->addr, &cur);
373
374
    }
    debug(DBG_WARN, "dtlsservernew: ignoring request, no matching TLS client");
venaas's avatar
venaas committed
375
376
377
378
379

    if (cert)
	X509_free(cert);

 exit:
380
381
382
383
    if (ssl) {
	SSL_shutdown(ssl);
	SSL_free(ssl);
    }
384
385
386
387
388
389
390
    pthread_mutex_lock(&params->sesscache->mutex);
    freebios(params->sesscache->rbios);
    params->sesscache->rbios = NULL;
    gettimeofday(&params->sesscache->expiry, NULL);
    params->sesscache->expiry.tv_sec += delay;
    pthread_mutex_unlock(&params->sesscache->mutex);
    free(params);
venaas's avatar
venaas committed
391
392
    ERR_remove_state(0);
    pthread_exit(NULL);
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
    debug(DBG_DBG, "dtlsservernew: exiting");
}

void cacheexpire(struct hash *cache, struct timeval *last) {
    struct timeval now;
    struct hash_entry *he;
    struct sessioncacheentry *e;
    
    gettimeofday(&now, NULL);
    if (now.tv_sec - last->tv_sec < 19)
	return;

    for (he = hash_first(cache); he; he = hash_next(he)) {
	e = (struct sessioncacheentry *)he->data;
	pthread_mutex_lock(&e->mutex);
	if (!e->expiry.tv_sec || e->expiry.tv_sec > now.tv_sec) {
	    pthread_mutex_unlock(&e->mutex);
	    continue;
	}
	debug(DBG_DBG, "cacheexpire: freeing entry");
	hash_extract(cache, he->key, he->keylen);
	if (e->rbios) {
	    freebios(e->rbios);
	    e->rbios = NULL;
	}
	pthread_mutex_unlock(&e->mutex);
	pthread_mutex_destroy(&e->mutex);
    }
    last->tv_sec = now.tv_sec;
}

void *udpdtlsserverrd(void *arg) {
    int ndesc, cnt, s = *(int *)arg;
    unsigned char buf[4];
    struct sockaddr_storage from;
    socklen_t fromlen = sizeof(from);
    struct dtlsservernewparams *params;
    fd_set readfds;
    struct timeval timeout, lastexpiry;
    pthread_t dtlsserverth;
    struct hash *sessioncache;
    struct sessioncacheentry *cacheentry;
    
    sessioncache = hash_create();
    if (!sessioncache)
	debugx(1, DBG_ERR, "udpdtlsserverrd: malloc failed");
    gettimeofday(&lastexpiry, NULL);
    
    for (;;) {
	FD_ZERO(&readfds);
        FD_SET(s, &readfds);
	memset(&timeout, 0, sizeof(struct timeval));
	timeout.tv_sec = 60;
	ndesc = select(s + 1, &readfds, NULL, NULL, &timeout);
	if (ndesc < 1) {
	    cacheexpire(sessioncache, &lastexpiry);
	    continue;
	}
	cnt = recvfrom(s, buf, 4, MSG_PEEK | MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
	if (cnt == -1) {
	    debug(DBG_WARN, "udpdtlsserverrd: recv failed");
	    cacheexpire(sessioncache, &lastexpiry);
	    continue;
	}
	cacheentry = hash_read(sessioncache, &from, fromlen);
	if (cacheentry) {
	    debug(DBG_DBG, "udpdtlsserverrd: cache hit");
	    pthread_mutex_lock(&cacheentry->mutex);
	    if (cacheentry->rbios) {
		if (udp2bio(s, cacheentry->rbios, cnt))
463
		    debug(DBG_DBG, "udpdtlsserverrd: got DTLS in UDP from %s", addr2string((struct sockaddr *)&from));
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
	    } else
		recv(s, buf, 1, 0);
	    pthread_mutex_unlock(&cacheentry->mutex);
	    cacheexpire(sessioncache, &lastexpiry);
	    continue;
	}

	/* from new source */
	debug(DBG_DBG, "udpdtlsserverrd: cache miss");
	params = malloc(sizeof(struct dtlsservernewparams));
	if (!params) {
	    cacheexpire(sessioncache, &lastexpiry);
	    recv(s, buf, 1, 0);
	    continue;
	}
	memset(params, 0, sizeof(struct dtlsservernewparams));
	params->sesscache = malloc(sizeof(struct sessioncacheentry));
	if (!params->sesscache) {
	    free(params);
	    cacheexpire(sessioncache, &lastexpiry);
	    recv(s, buf, 1, 0);
	    continue;
	}
	memset(params->sesscache, 0, sizeof(struct sessioncacheentry));
	pthread_mutex_init(&params->sesscache->mutex, NULL);
	params->sesscache->rbios = newqueue();
	if (hash_insert(sessioncache, &from, fromlen, params->sesscache)) {
	    params->sock = s;
	    memcpy(&params->addr, &from, fromlen);

	    if (udp2bio(s, params->sesscache->rbios, cnt)) {
495
		debug(DBG_DBG, "udpdtlsserverrd: got DTLS in UDP from %s", addr2string((struct sockaddr *)&from));
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
		if (!pthread_create(&dtlsserverth, NULL, dtlsservernew, (void *)params)) {
		    pthread_detach(dtlsserverth);
		    cacheexpire(sessioncache, &lastexpiry);
		    continue;
		}
		debug(DBG_ERR, "udpdtlsserverrd: pthread_create failed");
	    }
	    hash_extract(sessioncache, &from, fromlen);
	}
	freebios(params->sesscache->rbios);
	pthread_mutex_destroy(&params->sesscache->mutex);
	free(params->sesscache);
	free(params);
	cacheexpire(sessioncache, &lastexpiry);
    }
venaas's avatar
venaas committed
511
512
513
514
515
516
}

int dtlsconnect(struct server *server, struct timeval *when, int timeout, char *text) {
    struct timeval now;
    time_t elapsed;
    X509 *cert;
517
518
    SSL_CTX *ctx = NULL;

venaas's avatar
venaas committed
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
    debug(DBG_DBG, "dtlsconnect: called from %s", text);
    pthread_mutex_lock(&server->lock);
    if (when && memcmp(&server->lastconnecttry, when, sizeof(struct timeval))) {
	/* already reconnected, nothing to do */
	debug(DBG_DBG, "dtlsconnect(%s): seems already reconnected", text);
	pthread_mutex_unlock(&server->lock);
	return 1;
    }

    for (;;) {
	gettimeofday(&now, NULL);
	elapsed = now.tv_sec - server->lastconnecttry.tv_sec;

	if (timeout && server->lastconnecttry.tv_sec && elapsed > timeout) {
	    debug(DBG_DBG, "dtlsconnect: timeout");
	    SSL_free(server->ssl);
	    server->ssl = NULL;
	    pthread_mutex_unlock(&server->lock);
	    return 0;
	}

	if (server->connectionok) {
	    server->connectionok = 0;
	    sleep(2);
	} else if (elapsed < 1)
	    sleep(2);
	else if (elapsed < 60) {
	    debug(DBG_INFO, "dtlsconnect: sleeping %lds", elapsed);
	    sleep(elapsed);
	} else if (elapsed < 100000) {
	    debug(DBG_INFO, "dtlsconnect: sleeping %ds", 60);
	    sleep(60);
	} else
	    server->lastconnecttry.tv_sec = now.tv_sec;  /* no sleep at startup */
	debug(DBG_WARN, "dtlsconnect: trying to open DTLS connection to %s port %s", server->conf->host, server->conf->port);

	SSL_free(server->ssl);
556
	server->ssl = NULL;
venaas's avatar
venaas committed
557
	ctx = tlsgetctx(handle, server->conf->tlsconf);
558
559
560
	if (!ctx)
	    continue;
	server->ssl = dtlsacccon(0, ctx, server->sock, server->conf->addrinfo->ai_addr, server->rbios);
venaas's avatar
venaas committed
561
562
563
564
565
566
567
568
569
570
571
572
573
574
	if (!server->ssl)
	    continue;
	debug(DBG_DBG, "dtlsconnect: DTLS: ok");
	
	cert = verifytlscert(server->ssl);
	if (!cert)
	    continue;
	
	if (verifyconfcert(cert, server->conf))
	    break;
	X509_free(cert);
    }
    X509_free(cert);
    debug(DBG_WARN, "dtlsconnect: DTLS connection to %s port %s up", server->conf->host, server->conf->port);
575
    server->connectionok = 1;
venaas's avatar
venaas committed
576
577
578
579
580
581
582
583
584
585
    gettimeofday(&server->lastconnecttry, NULL);
    pthread_mutex_unlock(&server->lock);
    return 1;
}

int clientradputdtls(struct server *server, unsigned char *rad) {
    int cnt;
    size_t len;
    unsigned long error;
    struct clsrvconf *conf = server->conf;
586

587
    if (!server->connectionok)
588
	return 0;
venaas's avatar
venaas committed
589
    len = RADLEN(rad);
590
    if ((cnt = SSL_write(server->ssl, rad, len)) <= 0) {
venaas's avatar
venaas committed
591
592
	while ((error = ERR_get_error()))
	    debug(DBG_ERR, "clientradputdtls: DTLS: %s", ERR_error_string(error, NULL));
593
	return 0;
venaas's avatar
venaas committed
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
    }
    debug(DBG_DBG, "clientradputdtls: Sent %d bytes, Radius packet of length %d to DTLS peer %s", cnt, len, conf->host);
    return 1;
}

/* reads UDP containing DTLS and passes it on to dtlsclientrd */
void *udpdtlsclientrd(void *arg) {
    int cnt, s = *(int *)arg;
    unsigned char buf[4];
    struct sockaddr_storage from;
    socklen_t fromlen = sizeof(from);
    struct clsrvconf *conf;
    fd_set readfds;
    
    for (;;) {
	FD_ZERO(&readfds);
        FD_SET(s, &readfds);
	if (select(s + 1, &readfds, NULL, NULL, NULL) < 1)
	    continue;
	cnt = recvfrom(s, buf, 4, MSG_PEEK | MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
	if (cnt == -1) {
	    debug(DBG_WARN, "udpdtlsclientrd: recv failed");
	    continue;
	}
	
venaas's avatar
venaas committed
619
	conf = find_srvconf(handle, (struct sockaddr *)&from, NULL);
venaas's avatar
venaas committed
620
	if (!conf) {
621
	    debug(DBG_WARN, "udpdtlsclientrd: got packet from wrong or unknown DTLS peer %s, ignoring", addr2string((struct sockaddr *)&from));
venaas's avatar
venaas committed
622
623
624
625
	    recv(s, buf, 4, 0);
	    continue;
	}
	if (udp2bio(s, conf->servers->rbios, cnt))
626
	    debug(DBG_DBG, "radudpget: got DTLS in UDP from %s", addr2string((struct sockaddr *)&from));
venaas's avatar
venaas committed
627
628
629
630
631
632
633
    }
}

void *dtlsclientrd(void *arg) {
    struct server *server = (struct server *)arg;
    unsigned char *buf;
    struct timeval lastconnecttry;
634
    int secs;
venaas's avatar
venaas committed
635
636
637
638
    
    for (;;) {
	/* yes, lastconnecttry is really necessary */
	lastconnecttry = server->lastconnecttry;
639
	for (secs = 0; !(buf = raddtlsget(server->ssl, server->rbios, 10)) && !server->lostrqs && secs < IDLE_TIMEOUT; secs += 10);
venaas's avatar
venaas committed
640
641
642
643
	if (!buf) {
	    dtlsconnect(server, &lastconnecttry, 0, "dtlsclientrd");
	    continue;
	}
venaas's avatar
venaas committed
644
	replyh(server, buf);
venaas's avatar
venaas committed
645
    }
646
647
648
    ERR_remove_state(0);
    server->clientrdgone = 1;
    return NULL;
venaas's avatar
venaas committed
649
}
venaas's avatar
venaas committed
650
651
652
653
654

void addserverextradtls(struct clsrvconf *conf) {
    switch (conf->addrinfo->ai_family) {
    case AF_INET:
	if (client4_sock < 0) {
venaas's avatar
venaas committed
655
	    client4_sock = bindtoaddr(srcres, AF_INET, 0, 1);
venaas's avatar
venaas committed
656
657
658
659
660
661
662
	    if (client4_sock < 0)
		debugx(1, DBG_ERR, "addserver: failed to create client socket for server %s", conf->host);
	}
	conf->servers->sock = client4_sock;
	break;
    case AF_INET6:
	if (client6_sock < 0) {
venaas's avatar
venaas committed
663
	    client6_sock = bindtoaddr(srcres, AF_INET6, 0, 1);
venaas's avatar
venaas committed
664
665
666
667
668
669
670
671
672
673
674
675
	    if (client6_sock < 0)
		debugx(1, DBG_ERR, "addserver: failed to create client socket for server %s", conf->host);
	}
	conf->servers->sock = client6_sock;
	break;
    default:
	debugx(1, DBG_ERR, "addserver: unsupported address family");
    }
}

void initextradtls() {
    pthread_t cl4th, cl6th;
venaas's avatar
venaas committed
676
677
678
679
680

    if (srcres) {
	freeaddrinfo(srcres);
	srcres = NULL;
    }
venaas's avatar
venaas committed
681
682
683
684
685
686
687
688
    
    if (client4_sock >= 0)
	if (pthread_create(&cl4th, NULL, udpdtlsclientrd, (void *)&client4_sock))
	    debugx(1, DBG_ERR, "pthread_create failed");
    if (client6_sock >= 0)
	if (pthread_create(&cl6th, NULL, udpdtlsclientrd, (void *)&client6_sock))
	    debugx(1, DBG_ERR, "pthread_create failed");
}