tcp.c 8.9 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 31 32 33 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 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
/*
 * 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 "debug.h"
#include "list.h"
#include "util.h"
#include "radsecproxy.h"
#include "tcp.h"

int tcpconnect(struct server *server, struct timeval *when, int timeout, char *text) {
    struct timeval now;
    time_t elapsed;
    
    debug(DBG_DBG, "tcpconnect: 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, "tcpconnect(%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, "tcpconnect: timeout");
	    if (server->sock >= 0)
		close(server->sock);
	    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, "tcpconnect: sleeping %lds", elapsed);
	    sleep(elapsed);
	} else if (elapsed < 100000) {
	    debug(DBG_INFO, "tcpconnect: sleeping %ds", 60);
	    sleep(60);
	} else
	    server->lastconnecttry.tv_sec = now.tv_sec;  /* no sleep at startup */
	debug(DBG_WARN, "tcpconnect: trying to open TCP connection to %s port %s", server->conf->host, server->conf->port);
	if (server->sock >= 0)
	    close(server->sock);
	if ((server->sock = connecttcp(server->conf->addrinfo, getsrcprotores(RAD_TCP))) >= 0)
	    break;
	debug(DBG_ERR, "tcpconnect: connecttcp failed");
    }
    debug(DBG_WARN, "tcpconnect: TCP connection to %s port %s up", server->conf->host, server->conf->port);
78
    server->connectionok = 1;
venaas's avatar
venaas committed
79 80 81 82 83 84 85 86 87 88 89 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 146 147 148 149 150 151 152 153 154
    gettimeofday(&server->lastconnecttry, NULL);
    pthread_mutex_unlock(&server->lock);
    return 1;
}

/* timeout in seconds, 0 means no timeout (blocking), returns when num bytes have been read, or timeout */
/* returns 0 on timeout, -1 on error and num if ok */
int tcpreadtimeout(int s, unsigned char *buf, int num, int timeout) {
    int ndesc, cnt, len;
    fd_set readfds, writefds;
    struct timeval timer;
    
    if (s < 0)
	return -1;
    /* make socket non-blocking? */
    for (len = 0; len < num; len += cnt) {
	FD_ZERO(&readfds);
	FD_SET(s, &readfds);
	writefds = readfds;
	if (timeout) {
	    timer.tv_sec = timeout;
	    timer.tv_usec = 0;
	}
	ndesc = select(s + 1, &readfds, &writefds, NULL, timeout ? &timer : NULL);
	if (ndesc < 1)
	    return ndesc;

	cnt = read(s, buf + len, num - len);
	if (cnt <= 0)
	    return -1;
    }
    return num;
}

/* timeout in seconds, 0 means no timeout (blocking) */
unsigned char *radtcpget(int s, int timeout) {
    int cnt, len;
    unsigned char buf[4], *rad;

    for (;;) {
	cnt = tcpreadtimeout(s, buf, 4, timeout);
	if (cnt < 1) {
	    debug(DBG_DBG, cnt ? "radtcpget: connection lost" : "radtcpget: timeout");
	    return NULL;
	}

	len = RADLEN(buf);
	rad = malloc(len);
	if (!rad) {
	    debug(DBG_ERR, "radtcpget: malloc failed");
	    continue;
	}
	memcpy(rad, buf, 4);
	
	cnt = tcpreadtimeout(s, rad + 4, len - 4, timeout);
	if (cnt < 1) {
	    debug(DBG_DBG, cnt ? "radtcpget: connection lost" : "radtcpget: timeout");
	    free(rad);
	    return NULL;
	}
	
	if (len >= 20)
	    break;
	
	free(rad);
	debug(DBG_WARN, "radtcpget: packet smaller than minimum radius size");
    }
    
    debug(DBG_DBG, "radtcpget: got %d bytes", len);
    return rad;
}

int clientradputtcp(struct server *server, unsigned char *rad) {
    int cnt;
    size_t len;
    struct clsrvconf *conf = server->conf;
155 156 157

    if (!server->connectionok)
	return 0;
venaas's avatar
venaas committed
158
    len = RADLEN(rad);
159
    if ((cnt = write(server->sock, rad, len)) <= 0) {
venaas's avatar
venaas committed
160
	debug(DBG_ERR, "clientradputtcp: write error");
161
	return 0;
venaas's avatar
venaas committed
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
    }
    debug(DBG_DBG, "clientradputtcp: Sent %d bytes, Radius packet of length %d to TCP peer %s", cnt, len, conf->host);
    return 1;
}

void *tcpclientrd(void *arg) {
    struct server *server = (struct server *)arg;
    unsigned char *buf;
    struct timeval lastconnecttry;
    
    for (;;) {
	/* yes, lastconnecttry is really necessary */
	lastconnecttry = server->lastconnecttry;
	buf = radtcpget(server->sock, 0);
	if (!buf) {
	    tcpconnect(server, &lastconnecttry, 0, "tcpclientrd");
	    continue;
	}

venaas's avatar
venaas committed
181
	replyh(server, buf);
venaas's avatar
venaas committed
182 183 184 185 186 187 188 189 190
    }
    server->clientrdgone = 1;
    return NULL;
}

void *tcpserverwr(void *arg) {
    int cnt;
    struct client *client = (struct client *)arg;
    struct queue *replyq;
venaas's avatar
venaas committed
191
    struct request *reply;
venaas's avatar
venaas committed
192
    
193
    debug(DBG_DBG, "tcpserverwr: starting for %s", addr2string(client->addr));
venaas's avatar
venaas committed
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
    replyq = client->replyq;
    for (;;) {
	pthread_mutex_lock(&replyq->mutex);
	while (!list_first(replyq->entries)) {
	    if (client->sock >= 0) {	    
		debug(DBG_DBG, "tcpserverwr: waiting for signal");
		pthread_cond_wait(&replyq->cond, &replyq->mutex);
		debug(DBG_DBG, "tcpserverwr: got signal");
	    }
	    if (client->sock < 0) {
		/* s might have changed while waiting */
		pthread_mutex_unlock(&replyq->mutex);
		debug(DBG_DBG, "tcpserverwr: exiting as requested");
		pthread_exit(NULL);
	    }
	}
venaas's avatar
venaas committed
210
	reply = (struct request *)list_shift(replyq->entries);
venaas's avatar
venaas committed
211
	pthread_mutex_unlock(&replyq->mutex);
venaas's avatar
venaas committed
212
	cnt = write(client->sock, reply->replybuf, RADLEN(reply->replybuf));
venaas's avatar
venaas committed
213
	if (cnt > 0)
214 215
	    debug(DBG_DBG, "tcpserverwr: sent %d bytes, Radius packet of length %d to %s",
		  cnt, RADLEN(reply->replybuf), addr2string(client->addr));
venaas's avatar
venaas committed
216
	else
217
	    debug(DBG_ERR, "tcpserverwr: write error for %s", addr2string(client->addr));
venaas's avatar
venaas committed
218
	freerq(reply);
venaas's avatar
venaas committed
219 220 221 222
    }
}

void tcpserverrd(struct client *client) {
223 224
    struct request *rq;
    uint8_t *buf;
venaas's avatar
venaas committed
225 226
    pthread_t tcpserverwrth;
    
227
    debug(DBG_DBG, "tcpserverrd: starting for %s", addr2string(client->addr));
venaas's avatar
venaas committed
228 229 230 231 232 233 234
    
    if (pthread_create(&tcpserverwrth, NULL, tcpserverwr, (void *)client)) {
	debug(DBG_ERR, "tcpserverrd: pthread_create failed");
	return;
    }

    for (;;) {
235 236
	buf = radtcpget(client->sock, 0);
	if (!buf) {
237
	    debug(DBG_ERR, "tcpserverrd: connection from %s lost", addr2string(client->addr));
venaas's avatar
venaas committed
238 239
	    break;
	}
240
	debug(DBG_DBG, "tcpserverrd: got Radius message from %s", addr2string(client->addr));
241 242 243 244 245 246 247 248
	rq = newrequest();
	if (!rq) {
	    free(buf);
	    continue;
	}
	rq->buf = buf;
	rq->from = client;
	if (!radsrv(rq)) {
249
	    debug(DBG_ERR, "tcpserverrd: message authentication/validation failed, closing connection from %s", addr2string(client->addr));
venaas's avatar
venaas committed
250 251 252 253 254 255 256 257 258 259 260
	    break;
	}
    }

    /* stop writer by setting s to -1 and give signal in case waiting for data */
    client->sock = -1;
    pthread_mutex_lock(&client->replyq->mutex);
    pthread_cond_signal(&client->replyq->cond);
    pthread_mutex_unlock(&client->replyq->mutex);
    debug(DBG_DBG, "tcpserverrd: waiting for writer to end");
    pthread_join(tcpserverwrth, NULL);
261
    debug(DBG_DBG, "tcpserverrd: reader for %s exiting", addr2string(client->addr));
venaas's avatar
venaas committed
262 263 264 265
}
void *tcpservernew(void *arg) {
    int s;
    struct sockaddr_storage from;
venaas's avatar
venaas committed
266
    socklen_t fromlen = sizeof(from);
venaas's avatar
venaas committed
267 268 269 270 271 272 273 274
    struct clsrvconf *conf;
    struct client *client;

    s = *(int *)arg;
    if (getpeername(s, (struct sockaddr *)&from, &fromlen)) {
	debug(DBG_DBG, "tcpservernew: getpeername failed, exiting");
	goto exit;
    }
275
    debug(DBG_WARN, "tcpservernew: incoming TCP connection from %s", addr2string((struct sockaddr *)&from));
venaas's avatar
venaas committed
276 277 278

    conf = find_clconf(RAD_TCP, (struct sockaddr *)&from, NULL);
    if (conf) {
279
	client = addclient(conf, 1);
venaas's avatar
venaas committed
280 281
	if (client) {
	    client->sock = s;
282
	    client->addr = addr_copy((struct sockaddr *)&from);
venaas's avatar
venaas committed
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
	    tcpserverrd(client);
	    removeclient(client);
	} else
	    debug(DBG_WARN, "tcpservernew: failed to create new client instance");
    } else
	debug(DBG_WARN, "tcpservernew: ignoring request, no matching TCP client");

 exit:
    shutdown(s, SHUT_RDWR);
    close(s);
    pthread_exit(NULL);
}

void *tcplistener(void *arg) {
    pthread_t tcpserverth;
    int s, *sp = (int *)arg;
    struct sockaddr_storage from;
venaas's avatar
venaas committed
300
    socklen_t fromlen = sizeof(from);
venaas's avatar
venaas committed
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320

    listen(*sp, 0);

    for (;;) {
	s = accept(*sp, (struct sockaddr *)&from, &fromlen);
	if (s < 0) {
	    debug(DBG_WARN, "accept failed");
	    continue;
	}
	if (pthread_create(&tcpserverth, NULL, tcpservernew, (void *)&s)) {
	    debug(DBG_ERR, "tcplistener: pthread_create failed");
	    shutdown(s, SHUT_RDWR);
	    close(s);
	    continue;
	}
	pthread_detach(tcpserverth);
    }
    free(sp);
    return NULL;
}