X-Git-Url: http://git.sameswireless.fr/l2tpns.git/blobdiff_plain/9261b46e2d7de60d682f9af6fd4fc791741a98eb..ea99c373311aabddb98216d5d33c1fb94b6d3644:/l2tpns.c?ds=inline

diff --git a/l2tpns.c b/l2tpns.c
index 2184a05..813f2c7 100644
--- a/l2tpns.c
+++ b/l2tpns.c
@@ -1,10 +1,10 @@
 // L2TP Network Server
 // Adrian Kennard 2002
-// Copyright (c) 2003, 2004 Optus Internet Engineering
+// Copyright (c) 2003, 2004, 2005 Optus Internet Engineering
 // Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced
 // vim: sw=8 ts=8
 
-char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.68 2004/12/13 05:27:19 bodea Exp $";
+char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.83 2005/02/09 00:45:34 bodea Exp $";
 
 #include <arpa/inet.h>
 #include <assert.h>
@@ -19,6 +19,7 @@ char const *cvs_id_l2tpns = "$Id: l2tpns.c,v 1.68 2004/12/13 05:27:19 bodea Exp
 #include <sys/mman.h>
 #include <netdb.h>
 #include <netinet/in.h>
+#include <netinet/ip6.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -62,25 +63,32 @@ int clifd = -1;			// Socket listening for CLI connections.
 int snoopfd = -1;		// UDP file handle for sending out intercept data
 int *radfds = NULL;		// RADIUS requests file handles
 int ifrfd = -1;			// File descriptor for routing, etc
+int ifr6fd = -1;		// File descriptor for IPv6 routing, etc
+static int rand_fd = -1;	// Random data source
 time_t basetime = 0;		// base clock
 char hostname[1000] = "";	// us.
-static u32 sessionid = 0;	// session id for radius accounting
+static int tunidx;		// ifr_ifindex of tun device
+static uint32_t sessionid = 0;	// session id for radius accounting
 static int syslog_log = 0;	// are we logging to syslog
 static FILE *log_stream = NULL;	// file handle for direct logging (i.e. direct into file, not via syslog).
 extern int cluster_sockfd;	// Intra-cluster communications socket.
-u32 last_id = 0;		// Last used PPP SID. Can I kill this?? -- mo
+uint32_t last_id = 0;		// Last used PPP SID. Can I kill this?? -- mo
 
 struct cli_session_actions *cli_session_actions = NULL;	// Pending session changes requested by CLI
 struct cli_tunnel_actions *cli_tunnel_actions = NULL;	// Pending tunnel changes required by CLI
 
 static void *ip_hash[256];	// Mapping from IP address to session structures.
+struct ipv6radix {
+	int sess;
+	struct ipv6radix *branch;
+} ipv6_hash[256];		// Mapping from IPv6 address to session structures.
 
 // Traffic counters.
-static u32 udp_rx = 0, udp_rx_pkt = 0, udp_tx = 0;
-static u32 eth_rx = 0, eth_rx_pkt = 0;
-u32 eth_tx = 0;
+static uint32_t udp_rx = 0, udp_rx_pkt = 0, udp_tx = 0;
+static uint32_t eth_rx = 0, eth_rx_pkt = 0;
+uint32_t eth_tx = 0;
 
-static u32 ip_pool_size = 1;		// Size of the pool of addresses used for dynamic address allocation.
+static uint32_t ip_pool_size = 1;	// Size of the pool of addresses used for dynamic address allocation.
 time_t time_now = 0;			// Current time in seconds since epoch.
 static char time_now_string[64] = {0};	// Current time as a string.
 static char main_quit = 0;		// True if we're in the process of exiting.
@@ -94,18 +102,19 @@ config_descriptt config_values[] = {
 	CONFIG("debug", debug, INT),
 	CONFIG("log_file", log_filename, STRING),
 	CONFIG("pid_file", pid_file, STRING),
+	CONFIG("random_device", random_device, STRING),
 	CONFIG("l2tp_secret", l2tpsecret, STRING),
-	CONFIG("primary_dns", default_dns1, IP),
-	CONFIG("secondary_dns", default_dns2, IP),
-	CONFIG("save_state", save_state, BOOL),
-	CONFIG("primary_radius", radiusserver[0], IP),
-	CONFIG("secondary_radius", radiusserver[1], IP),
+	CONFIG("primary_dns", default_dns1, IPv4),
+	CONFIG("secondary_dns", default_dns2, IPv4),
+	CONFIG("primary_radius", radiusserver[0], IPv4),
+	CONFIG("secondary_radius", radiusserver[1], IPv4),
 	CONFIG("primary_radius_port", radiusport[0], SHORT),
 	CONFIG("secondary_radius_port", radiusport[1], SHORT),
 	CONFIG("radius_accounting", radius_accounting, BOOL),
 	CONFIG("radius_secret", radiussecret, STRING),
-	CONFIG("bind_address", bind_address, IP),
-	CONFIG("peer_address", peer_address, IP),
+	CONFIG("radius_authtypes", radius_authtypes_s, STRING),
+	CONFIG("bind_address", bind_address, IPv4),
+	CONFIG("peer_address", peer_address, IPv4),
 	CONFIG("send_garp", send_garp, BOOL),
 	CONFIG("throttle_speed", rl_rate, UNSIGNED_LONG),
 	CONFIG("throttle_buckets", num_tbfs, INT),
@@ -117,10 +126,12 @@ config_descriptt config_values[] = {
 	CONFIG("scheduler_fifo", scheduler_fifo, BOOL),
 	CONFIG("lock_pages", lock_pages, BOOL),
 	CONFIG("icmp_rate", icmp_rate, INT),
-	CONFIG("cluster_address", cluster_address, IP),
+	CONFIG("packet_limit", max_packets, INT),
+	CONFIG("cluster_address", cluster_address, IPv4),
 	CONFIG("cluster_interface", cluster_interface, STRING),
 	CONFIG("cluster_hb_interval", cluster_hb_interval, INT),
 	CONFIG("cluster_hb_timeout", cluster_hb_timeout, INT),
+	CONFIG("ipv6_prefix", ipv6_prefix, IPv6),
 	{ NULL, 0, 0, 0 },
 };
 
@@ -147,7 +158,7 @@ static sessionidt shut_acct_n = 0;
 
 tunnelt *tunnel = NULL;			// Array of tunnel structures.
 sessiont *session = NULL;		// Array of session structures.
-sessioncountt *sess_count = NULL;	// Array of partial per-session traffic counters.
+sessionlocalt *sess_local = NULL;	// Array of local per-session counters.
 radiust *radius = NULL;			// Array of radius structures.
 ippoolt *ip_address_pool = NULL;	// Array of dynamic IP addresses.
 ip_filtert *ip_filters = NULL;	// Array of named filters.
@@ -157,8 +168,9 @@ struct Tstats *_statistics = NULL;
 struct Tringbuffer *ringbuffer = NULL;
 #endif
 
-static void cache_ipmap(ipt ip, int s);
-static void uncache_ipmap(ipt ip);
+static void cache_ipmap(in_addr_t ip, int s);
+static void uncache_ipmap(in_addr_t ip);
+static void cache_ipv6map(struct in6_addr ip, int prefixlen, int s);
 static void free_ip_address(sessionidt s);
 static void dump_acct_info(int all);
 static void sighup_handler(int sig);
@@ -166,18 +178,16 @@ static void sigalrm_handler(int sig);
 static void sigterm_handler(int sig);
 static void sigquit_handler(int sig);
 static void sigchild_handler(int sig);
-static void read_state(void);
-static void dump_state(void);
-static void build_chap_response(char *challenge, u8 id, u16 challenge_length, char **challenge_response);
+static void build_chap_response(char *challenge, uint8_t id, uint16_t challenge_length, char **challenge_response);
 static void update_config(void);
 static void read_config_file(void);
 static void initplugins(void);
 static int add_plugin(char *plugin_name);
 static int remove_plugin(char *plugin_name);
 static void plugins_done(void);
-static void processcontrol(u8 * buf, int len, struct sockaddr_in *addr, int alen);
+static void processcontrol(uint8_t *buf, int len, struct sockaddr_in *addr, int alen);
 static tunnelidt new_tunnel(void);
-static int unhide_avp(u8 *avp, tunnelidt t, sessionidt s, u16 length);
+static int unhide_avp(uint8_t *avp, tunnelidt t, sessionidt s, uint16_t length);
 
 // return internal time (10ths since process startup)
 static clockt now(void)
@@ -190,7 +200,7 @@ static clockt now(void)
 // work out a retry time based on try number
 // This is a straight bounded exponential backoff.
 // Maximum re-try time is 32 seconds. (2^5).
-clockt backoff(u8 try)
+clockt backoff(uint8_t try)
 {
 	if (try > 5) try = 5;                  // max backoff
 	return now() + 10 * (1 << try);
@@ -203,7 +213,6 @@ clockt backoff(u8 try)
 void _log(int level, sessionidt s, tunnelidt t, const char *format, ...)
 {
 	static char message[65536] = {0};
-	static char message2[65536] = {0};
 	va_list ap;
 
 #ifdef RINGBUFFER
@@ -227,25 +236,20 @@ void _log(int level, sessionidt s, tunnelidt t, const char *format, ...)
 	if (config->debug < level) return;
 
 	va_start(ap, format);
+	vsnprintf(message, sizeof(message), format, ap);
+
 	if (log_stream)
-	{
-		vsnprintf(message2, 65535, format, ap);
-		snprintf(message, 65535, "%s %02d/%02d %s", time_now_string, t, s, message2);
-		fprintf(log_stream, "%s", message);
-	}
+		fprintf(log_stream, "%s %02d/%02d %s", time_now_string, t, s, message);
 	else if (syslog_log)
-	{
-		vsnprintf(message2, 65535, format, ap);
-		snprintf(message, 65535, "%02d/%02d %s", t, s, message2);
-		syslog(level + 2, message); // We don't need LOG_EMERG or LOG_ALERT
-	}
+		syslog(level + 2, "%02d/%02d %s", t, s, message); // We don't need LOG_EMERG or LOG_ALERT
+
 	va_end(ap);
 }
 
 void _log_hex(int level, const char *title, const char *data, int maxsize)
 {
 	int i, j;
-	const u8 *d = (const u8 *)data;
+	const uint8_t *d = (const uint8_t *) data;
 
 	if (config->debug < level) return;
 
@@ -293,6 +297,72 @@ void _log_hex(int level, const char *title, const char *data, int maxsize)
 	}
 }
 
+// initialise the random generator
+static void initrandom(char *source)
+{
+	static char path[sizeof(config->random_device)] = "*undefined*";
+
+	// reinitialise only if we are forced to do so or if the config has changed
+	if (source && !strncmp(path, source, sizeof(path)))
+		return;
+
+	// close previous source, if any
+	if (rand_fd >= 0) close(rand_fd);
+
+	rand_fd = -1;
+
+	if (source)
+	{
+		// register changes
+		snprintf(path, sizeof(path), "%s", source);
+
+		if (*path == '/')
+		{
+			rand_fd = open(path, O_RDONLY|O_NONBLOCK);
+			if (rand_fd < 0)
+				LOG(0, 0, 0, "Error opening the random device %s: %s\n",
+					path, strerror(errno));
+		}
+	}
+
+	// no source: seed prng
+	{
+		unsigned seed = time_now ^ getpid();
+		LOG(4, 0, 0, "Seeding the pseudo random generator: %u\n", seed);
+		srand(seed);
+	}
+}
+
+// fill buffer with random data
+void random_data(uint8_t *buf, int len)
+{
+	int n = 0;
+
+	CSTAT(random_data);
+	if (rand_fd >= 0)
+	{
+		n = read(rand_fd, buf, len);
+		if (n >= len) return;
+		if (n < 0)
+		{
+			if (errno != EAGAIN)
+			{
+				LOG(0, 0, 0, "Error reading from random source: %s\n",
+					strerror(errno));
+
+				// fall back to rand()
+				initrandom(0);
+			}
+
+			n = 0;
+		}
+	}
+
+	// append missing data
+	while (n < len)
+		// not using the low order bits from the prng stream
+		buf[n++] = (rand() >> 4) & 0xff;
+}
 
 // Add a route
 //
@@ -302,7 +372,7 @@ void _log_hex(int level, const char *title, const char *data, int maxsize)
 //
 // 'ip' and 'mask' must be in _host_ order.
 //
-static void routeset(sessionidt s, ipt ip, ipt mask, ipt gw, u8 add)
+static void routeset(sessionidt s, in_addr_t ip, in_addr_t mask, in_addr_t gw, int add)
 {
 	struct rtentry r;
 	int i;
@@ -314,11 +384,11 @@ static void routeset(sessionidt s, ipt ip, ipt mask, ipt gw, u8 add)
 	memset(&r, 0, sizeof(r));
 	r.rt_dev = config->tundevice;
 	r.rt_dst.sa_family = AF_INET;
-	*(u32 *) & (((struct sockaddr_in *) &r.rt_dst)->sin_addr.s_addr) = htonl(ip);
+	*(uint32_t *) & (((struct sockaddr_in *) &r.rt_dst)->sin_addr.s_addr) = htonl(ip);
 	r.rt_gateway.sa_family = AF_INET;
-	*(u32 *) & (((struct sockaddr_in *) &r.rt_gateway)->sin_addr.s_addr) = htonl(gw);
+	*(uint32_t *) & (((struct sockaddr_in *) &r.rt_gateway)->sin_addr.s_addr) = htonl(gw);
 	r.rt_genmask.sa_family = AF_INET;
-	*(u32 *) & (((struct sockaddr_in *) &r.rt_genmask)->sin_addr.s_addr) = htonl(mask);
+	*(uint32_t *) & (((struct sockaddr_in *) &r.rt_genmask)->sin_addr.s_addr) = htonl(mask);
 	r.rt_flags = (RTF_UP | RTF_STATIC);
 	if (gw)
 		r.rt_flags |= RTF_GATEWAY;
@@ -357,11 +427,61 @@ static void routeset(sessionidt s, ipt ip, ipt mask, ipt gw, u8 add)
 	}
 }
 
+void route6set(sessionidt s, struct in6_addr ip, int prefixlen, int add)
+{
+	struct in6_rtmsg rt;
+	char ipv6addr[INET6_ADDRSTRLEN];
+
+	if (ifr6fd < 0)
+	{
+		LOG(0, 0, 0, "Asked to set IPv6 route, but IPv6 not setup.\n");
+		return;
+	}
+
+	memset(&rt, 0, sizeof(rt));
+
+	memcpy(&rt.rtmsg_dst, &ip, sizeof(struct in6_addr));
+	rt.rtmsg_dst_len = prefixlen;
+	rt.rtmsg_metric = 1;
+	rt.rtmsg_flags = RTF_UP;
+	rt.rtmsg_ifindex = tunidx;
+
+	LOG(1, 0, 0, "Route %s %s/%d\n",
+	    add ? "add" : "del",
+	    inet_ntop(AF_INET6, &ip, ipv6addr, INET6_ADDRSTRLEN),
+	    prefixlen);
+
+	if (ioctl(ifr6fd, add ? SIOCADDRT : SIOCDELRT, (void *) &rt) < 0)
+		LOG(0, 0, 0, "route6set() error in ioctl: %s\n",
+				strerror(errno));
+
+	// FIXME: need to add BGP routing (RFC2858)
+
+	if (s)
+	{
+		if (!add)	// Are we deleting a route?
+			s = 0;	// Caching the session as '0' is the same as uncaching.
+
+		cache_ipv6map(ip, prefixlen, s);
+	}
+	
+	return;
+}
+
+// defined in linux/ipv6.h, but tricky to include from user-space
+// TODO: move routing to use netlink rather than ioctl
+struct in6_ifreq {
+	struct in6_addr ifr6_addr;
+	__u32 ifr6_prefixlen;
+	unsigned int ifr6_ifindex;
+};
+
 //
 // Set up TUN interface
 static void inittun(void)
 {
 	struct ifreq ifr;
+	struct in6_ifreq ifr6;
 	struct sockaddr_in sin = {0};
 	memset(&ifr, 0, sizeof(ifr));
 	ifr.ifr_flags = IFF_TUN;
@@ -407,6 +527,42 @@ static void inittun(void)
 		LOG(0, 0, 0, "Error setting tun flags: %s\n", strerror(errno));
 		exit(1);
 	}
+	if (ioctl(ifrfd, SIOCGIFINDEX, (void *) &ifr) < 0)
+	{
+		LOG(0, 0, 0, "Error getting tun ifindex: %s\n", strerror(errno));
+		exit(1);
+	}
+	tunidx = ifr.ifr_ifindex;
+
+	// Only setup IPv6 on the tun device if we have a configured prefix
+	if (config->ipv6_prefix.s6_addr[0] > 0) {
+		ifr6fd = socket(PF_INET6, SOCK_DGRAM, 0);
+
+		// Link local address is FE80::1
+		memset(&ifr6.ifr6_addr, 0, sizeof(ifr6.ifr6_addr));
+		ifr6.ifr6_addr.s6_addr[0] = 0xFE;
+		ifr6.ifr6_addr.s6_addr[1] = 0x80;
+		ifr6.ifr6_addr.s6_addr[15] = 1;
+		ifr6.ifr6_prefixlen = 64;
+		ifr6.ifr6_ifindex = ifr.ifr_ifindex;
+		if (ioctl(ifr6fd, SIOCSIFADDR, (void *) &ifr6) < 0)
+		{
+			LOG(0, 0, 0, "Error setting tun IPv6 link local address:"
+				" %s\n", strerror(errno));
+		}
+
+		// Global address is prefix::1
+		memset(&ifr6.ifr6_addr, 0, sizeof(ifr6.ifr6_addr));
+		ifr6.ifr6_addr = config->ipv6_prefix;
+		ifr6.ifr6_addr.s6_addr[15] = 1;
+		ifr6.ifr6_prefixlen = 64;
+		ifr6.ifr6_ifindex = ifr.ifr_ifindex;
+		if (ioctl(ifr6fd, SIOCSIFADDR, (void *) &ifr6) < 0)
+		{
+			LOG(0, 0, 0, "Error setting tun IPv6 global address: %s\n",
+				strerror(errno));
+		}
+	}
 }
 
 // set up UDP port
@@ -461,27 +617,71 @@ static void initudp(void)
 // IP address.
 //
 
-static int lookup_ipmap(ipt ip)
+static int lookup_ipmap(in_addr_t ip)
+{
+	uint8_t *a = (uint8_t *) &ip;
+	uint8_t **d = (uint8_t **) ip_hash;
+
+	if (!(d = (uint8_t **) d[(size_t) *a++])) return 0;
+	if (!(d = (uint8_t **) d[(size_t) *a++])) return 0;
+	if (!(d = (uint8_t **) d[(size_t) *a++])) return 0;
+
+	return (int) (intptr_t) d[(size_t) *a];
+}
+
+static int lookup_ipv6map(struct in6_addr ip)
 {
-	u8 *a = (u8 *)&ip;
-	char **d = (char **) ip_hash;
+	struct ipv6radix *curnode;
+	int i;
 	int s;
+	char ipv6addr[INET6_ADDRSTRLEN];
+
+	curnode = &ipv6_hash[ip.s6_addr[0]];
+	i = 1;
+	s = curnode->sess;
+
+	while (s == 0 && i < 15 && curnode->branch != NULL)
+	{
+		curnode = &curnode->branch[ip.s6_addr[i]];
+		s = curnode->sess;
+		i++;
+	}
 
-	if (!(d = (char **) d[(size_t) *a++])) return 0;
-	if (!(d = (char **) d[(size_t) *a++])) return 0;
-	if (!(d = (char **) d[(size_t) *a++])) return 0;
+	LOG(4, s, session[s].tunnel, "Looking up address %s and got %d\n",
+    			inet_ntop(AF_INET6, &ip, ipv6addr,
+				INET6_ADDRSTRLEN),
+			s);
 
-	s = (ipt) d[(size_t) *a];
 	return s;
 }
 
-sessionidt sessionbyip(ipt ip)
+sessionidt sessionbyip(in_addr_t ip)
 {
 	int s = lookup_ipmap(ip);
-	CSTAT(call_sessionbyip);
+	CSTAT(sessionbyip);
+
+	if (s > 0 && s < MAXSESSION && session[s].tunnel)
+		return (sessionidt) s;
+
+	return 0;
+}
+
+sessionidt sessionbyipv6(struct in6_addr ip)
+{
+	int s;
+	CSTAT(sessionbyipv6);
+
+	if (!memcmp(&config->ipv6_prefix, &ip, 8) ||
+		(ip.s6_addr[0] == 0xFE && ip.s6_addr[1] == 0x80 &&
+		 (ip.s6_addr16[1] == ip.s6_addr16[2] == ip.s6_addr16[3] == 0))) {
+		s = lookup_ipmap(*(in_addr_t *) &ip.s6_addr[8]);
+	} else {
+		s = lookup_ipv6map(ip);
+	}
 
 	if (s > 0 && s < MAXSESSION && session[s].tunnel)
 		return s;
+
 	return 0;
 }
 
@@ -491,25 +691,25 @@ sessionidt sessionbyip(ipt ip)
 //
 // (It's actually cached in network order)
 //
-static void cache_ipmap(ipt ip, int s)
+static void cache_ipmap(in_addr_t ip, int s)
 {
-	ipt nip = htonl(ip);		// MUST be in network order. I.e. MSB must in be ((char*)(&ip))[0]
-	u8 *a = (u8 *) &nip;
-	char **d = (char **) ip_hash;
+	in_addr_t nip = htonl(ip);	// MUST be in network order. I.e. MSB must in be ((char *) (&ip))[0]
+	uint8_t *a = (uint8_t *) &nip;
+	uint8_t **d = (uint8_t **) ip_hash;
 	int i;
 
 	for (i = 0; i < 3; i++)
 	{
 		if (!d[(size_t) a[i]])
 		{
-			if (!(d[(size_t) a[i]] = calloc(256, sizeof (void *))))
+			if (!(d[(size_t) a[i]] = calloc(256, sizeof(void *))))
 				return;
 		}
 
-		d = (char **) d[(size_t) a[i]];
+		d = (uint8_t **) d[(size_t) a[i]];
 	}
 
-	d[(size_t) a[3]] = (char *)((int)s);
+	d[(size_t) a[3]] = (uint8_t *) (intptr_t) s;
 
 	if (s > 0)
 		LOG(4, s, session[s].tunnel, "Caching ip address %s\n", fmtaddr(nip, 0));
@@ -519,11 +719,47 @@ static void cache_ipmap(ipt ip, int s)
 	// else a map to an ip pool index.
 }
 
-static void uncache_ipmap(ipt ip)
+static void uncache_ipmap(in_addr_t ip)
 {
 	cache_ipmap(ip, 0);	// Assign it to the NULL session.
 }
 
+static void cache_ipv6map(struct in6_addr ip, int prefixlen, int s)
+{
+	int i;
+	int bytes;
+	struct ipv6radix *curnode;
+	char ipv6addr[INET6_ADDRSTRLEN];
+
+	curnode = &ipv6_hash[ip.s6_addr[0]];
+
+	bytes = prefixlen >> 3;
+	i = 1;
+	while (i < bytes) {
+		if (curnode->branch == NULL)
+		{
+			if (!(curnode->branch = calloc(256,
+					sizeof (struct ipv6radix))))
+				return;
+		}
+		curnode = &curnode->branch[ip.s6_addr[i]];
+		i++;
+	}
+
+	curnode->sess = s;
+
+	if (s > 0)
+		LOG(4, s, session[s].tunnel, "Caching ip address %s/%d\n",
+	    			inet_ntop(AF_INET6, &ip, ipv6addr, 
+					INET6_ADDRSTRLEN),
+				prefixlen);
+	else if (s == 0)
+		LOG(4, 0, 0, "Un-caching ip address %s/%d\n",
+	    			inet_ntop(AF_INET6, &ip, ipv6addr, 
+					INET6_ADDRSTRLEN),
+				prefixlen);
+}
+
 //
 // CLI list to dump current ipcache.
 //
@@ -542,22 +778,22 @@ int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc)
 	{
 		if (!d[i])
 			continue;
-		e = (char**) d[i];
+		e = (char **) d[i];
 		for (j = 0; j < 256; ++j)
 		{
 			if (!e[j])
 				continue;
-			f = (char**) e[j];
+			f = (char **) e[j];
 			for (k = 0; k < 256; ++k)
 			{
 				if (!f[k])
 					continue;
-				g = (char**)f[k];
+				g = (char **)f[k];
 				for (l = 0; l < 256; ++l)
 				{
 					if (!g[l])
 						continue;
-					cli_print(cli, "%7d %d.%d.%d.%d", (int) g[l], i, j, k, l);
+					cli_print(cli, "%7d %d.%d.%d.%d", (int) (intptr_t) g[l], i, j, k, l);
 					++count;
 				}
 			}
@@ -577,7 +813,7 @@ int cmd_show_ipcache(struct cli_def *cli, char *command, char **argv, int argc)
 sessionidt sessionbyuser(char *username)
 {
 	int s;
-	CSTAT(call_sessionbyuser);
+	CSTAT(sessionbyuser);
 
 	for (s = 1; s < MAXSESSION ; ++s)
 	{
@@ -591,11 +827,11 @@ sessionidt sessionbyuser(char *username)
 	return 0;	// Not found.
 }
 
-void send_garp(ipt ip)
+void send_garp(in_addr_t ip)
 {
 	int s;
 	struct ifreq ifr;
-	u8 mac[6];
+	uint8_t mac[6];
 
 	s = socket(PF_INET, SOCK_DGRAM, 0);
 	if (s < 0)
@@ -637,11 +873,11 @@ static sessionidt sessionidtbysessiont(sessiont *s)
 }
 
 // actually send a control message for a specific tunnel
-void tunnelsend(u8 * buf, u16 l, tunnelidt t)
+void tunnelsend(uint8_t * buf, uint16_t l, tunnelidt t)
 {
 	struct sockaddr_in addr;
 
-	CSTAT(call_tunnelsend);
+	CSTAT(tunnelsend);
 
 	if (!t)
 	{
@@ -663,11 +899,11 @@ void tunnelsend(u8 * buf, u16 l, tunnelidt t)
 
 	memset(&addr, 0, sizeof(addr));
 	addr.sin_family = AF_INET;
-	*(u32 *) & addr.sin_addr = htonl(tunnel[t].ip);
+	*(uint32_t *) & addr.sin_addr = htonl(tunnel[t].ip);
 	addr.sin_port = htons(tunnel[t].port);
 
 	// sequence expected, if sequence in message
-	if (*buf & 0x08) *(u16 *) (buf + ((*buf & 0x40) ? 10 : 8)) = htons(tunnel[t].nr);
+	if (*buf & 0x08) *(uint16_t *) (buf + ((*buf & 0x40) ? 10 : 8)) = htons(tunnel[t].nr);
 
 	// If this is a control message, deal with retries
 	if (*buf & 0x80)
@@ -683,7 +919,7 @@ void tunnelsend(u8 * buf, u16 l, tunnelidt t)
 
 	if (sendto(udpfd, buf, l, 0, (void *) &addr, sizeof(addr)) < 0)
 	{
-		LOG(0, ntohs((*(u16 *) (buf + 6))), t, "Error sending data out tunnel: %s (udpfd=%d, buf=%p, len=%d, dest=%s)\n",
+		LOG(0, ntohs((*(uint16_t *) (buf + 6))), t, "Error sending data out tunnel: %s (udpfd=%d, buf=%p, len=%d, dest=%s)\n",
 				strerror(errno), udpfd, buf, l, inet_ntoa(addr.sin_addr));
 		STAT(tunnel_tx_errors);
 		return;
@@ -698,37 +934,37 @@ void tunnelsend(u8 * buf, u16 l, tunnelidt t)
 // Tiny helper function to write data to
 // the 'tun' device.
 //
-int tun_write(u8 * data, int size)
+int tun_write(uint8_t * data, int size)
 {
 	return write(tunfd, data, size);
 }
 
 // process outgoing (to tunnel) IP
 //
-static void processipout(u8 * buf, int len)
+static void processipout(uint8_t * buf, int len)
 {
 	sessionidt s;
 	sessiont *sp;
 	tunnelidt t;
-	ipt ip;
+	in_addr_t ip;
 
-	char * data = buf;	// Keep a copy of the originals.
+	char *data = buf;	// Keep a copy of the originals.
 	int size = len;
 
-	u8 b[MAXETHER + 20];
+	uint8_t b[MAXETHER + 20];
 
-	CSTAT(call_processipout);
+	CSTAT(processipout);
 
 	if (len < MIN_IP_SIZE)
 	{
 		LOG(1, 0, 0, "Short IP, %d bytes\n", len);
-		STAT(tunnel_tx_errors);
+		STAT(tun_rx_errors);
 		return;
 	}
 	if (len >= MAXETHER)
 	{
 		LOG(1, 0, 0, "Oversize IP packet %d bytes\n", len);
-		STAT(tunnel_tx_errors);
+		STAT(tun_rx_errors);
 		return;
 	}
 
@@ -737,13 +973,13 @@ static void processipout(u8 * buf, int len)
 	len -= 4;
 
 	// Got an IP header now
-	if (*(u8 *)(buf) >> 4 != 4)
+	if (*(uint8_t *)(buf) >> 4 != 4)
 	{
 		LOG(1, 0, 0, "IP: Don't understand anything except IPv4\n");
 		return;
 	}
 
-	ip = *(u32 *)(buf + 16);
+	ip = *(uint32_t *)(buf + 16);
 	if (!(s = sessionbyip(ip)))
 	{
 		// Is this a packet for a session that doesn't exist?
@@ -758,14 +994,53 @@ static void processipout(u8 * buf, int len)
 
 		if (rate++ < config->icmp_rate) // Only send a max of icmp_rate per second.
 		{
-			LOG(4, 0, 0, "IP: Sending ICMP host unreachable to %s\n", fmtaddr(*(u32 *)(buf + 12), 0));
-			host_unreachable(*(u32 *)(buf + 12), *(u16 *)(buf + 4), ip, buf, (len < 64) ? 64 : len);
+			LOG(4, 0, 0, "IP: Sending ICMP host unreachable to %s\n", fmtaddr(*(in_addr_t *)(buf + 12), 0));
+			host_unreachable(*(in_addr_t *)(buf + 12), *(uint16_t *)(buf + 4), ip, buf, (len < 64) ? 64 : len);
 		}
 		return;
 	}
 	t = session[s].tunnel;
 	sp = &session[s];
 
+	// DoS prevention: enforce a maximum number of packets per 0.1s for a session
+	if (config->max_packets > 0)
+	{
+		if (sess_local[s].last_packet_out == TIME)
+		{
+			int max = config->max_packets;
+
+			// All packets for throttled sessions are handled by the
+			// master, so further limit by using the throttle rate.
+			// A bit of a kludge, since throttle rate is in kbps,
+			// but should still be generous given our average DSL
+			// packet size is 200 bytes: a limit of 28kbps equates
+			// to around 180 packets per second.
+			if (!config->cluster_iam_master && sp->throttle_out && sp->throttle_out < max)
+				max = sp->throttle_out;
+
+			if (++sess_local[s].packets_out > max)
+			{
+				sess_local[s].packets_dropped++;
+				return;
+			}
+		}
+		else
+		{
+			if (sess_local[s].packets_dropped)
+			{
+				INC_STAT(tun_rx_dropped, sess_local[s].packets_dropped);
+				LOG(3, s, t, "Dropped %u/%u packets to %s for %suser %s\n",
+					sess_local[s].packets_dropped, sess_local[s].packets_out,
+					fmtaddr(ip, 0), sp->throttle_out ? "throttled " : "",
+					sp->user);
+			}
+
+			sess_local[s].last_packet_out = TIME;
+			sess_local[s].packets_out = 1;
+			sess_local[s].packets_dropped = 0;
+		}
+	}
+
 	// run access-list if any
 	if (session[s].filter_out && !ip_filter(buf, len, session[s].filter_out - 1))
 		return;
@@ -790,7 +1065,116 @@ static void processipout(u8 * buf, int len)
 
 	// Add on L2TP header
 	{
-		u8 *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP);
+		uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIP);
+		if (!p) return;
+		tunnelsend(b, len + (p-b), t); // send it...
+	}
+
+	// Snooping this session, send it to intercept box
+	if (sp->snoop_ip && sp->snoop_port)
+		snoop_send_packet(buf, len, sp->snoop_ip, sp->snoop_port);
+
+	sp->cout += len; // byte count
+	sp->total_cout += len; // byte count
+	sp->pout++;
+	udp_tx += len;
+	sess_local[s].cout += len;	// To send to master..
+}
+
+// process outgoing (to tunnel) IPv6
+//
+static void processipv6out(uint8_t * buf, int len)
+{
+	sessionidt s;
+	sessiont *sp;
+	tunnelidt t;
+	in_addr_t ip;
+	struct in6_addr ip6;
+
+	char *data = buf;	// Keep a copy of the originals.
+	int size = len;
+
+	uint8_t b[MAXETHER + 20];
+
+	CSTAT(processipv6out);
+
+	if (len < MIN_IP_SIZE)
+	{
+		LOG(1, 0, 0, "Short IPv6, %d bytes\n", len);
+		STAT(tunnel_tx_errors);
+		return;
+	}
+	if (len >= MAXETHER)
+	{
+		LOG(1, 0, 0, "Oversize IPv6 packet %d bytes\n", len);
+		STAT(tunnel_tx_errors);
+		return;
+	}
+
+	// Skip the tun header
+	buf += 4;
+	len -= 4;
+
+	// Got an IP header now
+	if (*(uint8_t *)(buf) >> 4 != 6)
+	{
+		LOG(1, 0, 0, "IP: Don't understand anything except IPv6\n");
+		return;
+	}
+
+	ip6 = *(struct in6_addr *)(buf+24);
+	s = sessionbyipv6(ip6);
+
+	if (s == 0)
+	{
+		ip = *(uint32_t *)(buf + 32);
+		s = sessionbyip(ip);
+	}
+	
+	if (s == 0)
+	{
+		// Is this a packet for a session that doesn't exist?
+		static int rate = 0;	// Number of ICMP packets we've sent this second.
+		static int last = 0;	// Last time we reset the ICMP packet counter 'rate'.
+
+		if (last != time_now)
+		{
+			last = time_now;
+			rate = 0;
+		}
+
+		if (rate++ < config->icmp_rate) // Only send a max of icmp_rate per second.
+		{
+			// FIXME: Should send icmp6 host unreachable
+		}
+		return;
+	}
+	t = session[s].tunnel;
+	sp = &session[s];
+
+	// FIXME: add DoS prevention/filters?
+
+	if (sp->tbf_out)
+	{
+		// Are we throttling this session?
+		if (config->cluster_iam_master)
+			tbf_queue_packet(sp->tbf_out, data, size);
+		else
+			master_throttle_packet(sp->tbf_out, data, size);
+		return;
+	}
+	else if (sp->walled_garden && !config->cluster_iam_master)
+	{
+		// We are walled-gardening this
+		master_garden_packet(s, data, size);
+		return;
+	}
+
+	LOG(5, s, t, "Ethernet -> Tunnel (%d bytes)\n", len);
+
+	// Add on L2TP header
+	{
+		uint8_t *p = makeppp(b, sizeof(b), buf, len, t, s, PPPIPV6);
 		if (!p) return;
 		tunnelsend(b, len + (p-b), t); // send it...
 	}
@@ -803,20 +1187,20 @@ static void processipout(u8 * buf, int len)
 	sp->total_cout += len; // byte count
 	sp->pout++;
 	udp_tx += len;
-	sess_count[s].cout += len;	// To send to master..
+	sess_local[s].cout += len;	// To send to master..
 }
 
 //
 // Helper routine for the TBF filters.
 // Used to send queued data in to the user!
 //
-static void send_ipout(sessionidt s, u8 *buf, int len)
+static void send_ipout(sessionidt s, uint8_t *buf, int len)
 {
 	sessiont *sp;
 	tunnelidt t;
-	ipt ip;
+	in_addr_t ip;
 
-	u8 b[MAXETHER + 20];
+	uint8_t b[MAXETHER + 20];
 
 	if (len < 0 || len > MAXETHER)
 	{
@@ -828,7 +1212,7 @@ static void send_ipout(sessionidt s, u8 *buf, int len)
 	buf += 4;
 	len -= 4;
 
-	ip = *(u32 *)(buf + 16);
+	ip = *(in_addr_t *)(buf + 16);
 
 	if (!session[s].ip)
 		return;
@@ -840,7 +1224,7 @@ static void send_ipout(sessionidt s, u8 *buf, int len)
 
 	// Add on L2TP header
 	{
-		u8 *p = makeppp(b, sizeof(b),  buf, len, t, s, PPPIP);
+		uint8_t *p = makeppp(b, sizeof(b),  buf, len, t, s, PPPIP);
 		if (!p) return;
 		tunnelsend(b, len + (p-b), t); // send it...
 	}
@@ -853,55 +1237,55 @@ static void send_ipout(sessionidt s, u8 *buf, int len)
 	sp->total_cout += len; // byte count
 	sp->pout++;
 	udp_tx += len;
-	sess_count[s].cout += len;	// To send to master..
+	sess_local[s].cout += len;	// To send to master..
 }
 
 // add an AVP (16 bit)
-static void control16(controlt * c, u16 avp, u16 val, u8 m)
+static void control16(controlt * c, uint16_t avp, uint16_t val, uint8_t m)
 {
-	u16 l = (m ? 0x8008 : 0x0008);
-	*(u16 *) (c->buf + c->length + 0) = htons(l);
-	*(u16 *) (c->buf + c->length + 2) = htons(0);
-	*(u16 *) (c->buf + c->length + 4) = htons(avp);
-	*(u16 *) (c->buf + c->length + 6) = htons(val);
+	uint16_t l = (m ? 0x8008 : 0x0008);
+	*(uint16_t *) (c->buf + c->length + 0) = htons(l);
+	*(uint16_t *) (c->buf + c->length + 2) = htons(0);
+	*(uint16_t *) (c->buf + c->length + 4) = htons(avp);
+	*(uint16_t *) (c->buf + c->length + 6) = htons(val);
 	c->length += 8;
 }
 
 // add an AVP (32 bit)
-static void control32(controlt * c, u16 avp, u32 val, u8 m)
+static void control32(controlt * c, uint16_t avp, uint32_t val, uint8_t m)
 {
-	u16 l = (m ? 0x800A : 0x000A);
-	*(u16 *) (c->buf + c->length + 0) = htons(l);
-	*(u16 *) (c->buf + c->length + 2) = htons(0);
-	*(u16 *) (c->buf + c->length + 4) = htons(avp);
-	*(u32 *) (c->buf + c->length + 6) = htonl(val);
+	uint16_t l = (m ? 0x800A : 0x000A);
+	*(uint16_t *) (c->buf + c->length + 0) = htons(l);
+	*(uint16_t *) (c->buf + c->length + 2) = htons(0);
+	*(uint16_t *) (c->buf + c->length + 4) = htons(avp);
+	*(uint32_t *) (c->buf + c->length + 6) = htonl(val);
 	c->length += 10;
 }
 
 // add an AVP (32 bit)
-static void controls(controlt * c, u16 avp, char *val, u8 m)
+static void controls(controlt * c, uint16_t avp, char *val, uint8_t m)
 {
-	u16 l = ((m ? 0x8000 : 0) + strlen(val) + 6);
-	*(u16 *) (c->buf + c->length + 0) = htons(l);
-	*(u16 *) (c->buf + c->length + 2) = htons(0);
-	*(u16 *) (c->buf + c->length + 4) = htons(avp);
+	uint16_t l = ((m ? 0x8000 : 0) + strlen(val) + 6);
+	*(uint16_t *) (c->buf + c->length + 0) = htons(l);
+	*(uint16_t *) (c->buf + c->length + 2) = htons(0);
+	*(uint16_t *) (c->buf + c->length + 4) = htons(avp);
 	memcpy(c->buf + c->length + 6, val, strlen(val));
 	c->length += 6 + strlen(val);
 }
 
 // add a binary AVP
-static void controlb(controlt * c, u16 avp, char *val, unsigned int len, u8 m)
+static void controlb(controlt * c, uint16_t avp, char *val, unsigned int len, uint8_t m)
 {
-	u16 l = ((m ? 0x8000 : 0) + len + 6);
-	*(u16 *) (c->buf + c->length + 0) = htons(l);
-	*(u16 *) (c->buf + c->length + 2) = htons(0);
-	*(u16 *) (c->buf + c->length + 4) = htons(avp);
+	uint16_t l = ((m ? 0x8000 : 0) + len + 6);
+	*(uint16_t *) (c->buf + c->length + 0) = htons(l);
+	*(uint16_t *) (c->buf + c->length + 2) = htons(0);
+	*(uint16_t *) (c->buf + c->length + 4) = htons(avp);
 	memcpy(c->buf + c->length + 6, val, len);
 	c->length += 6 + len;
 }
 
 // new control connection
-static controlt *controlnew(u16 mtype)
+static controlt *controlnew(uint16_t mtype)
 {
 	controlt *c;
 	if (!controlfree)
@@ -913,7 +1297,7 @@ static controlt *controlnew(u16 mtype)
 	}
 	assert(c);
 	c->next = 0;
-	*(u16 *) (c->buf + 0) = htons(0xC802); // flags/ver
+	*(uint16_t *) (c->buf + 0) = htons(0xC802); // flags/ver
 	c->length = 12;
 	control16(c, 0, mtype, 1);
 	return c;
@@ -923,26 +1307,26 @@ static controlt *controlnew(u16 mtype)
 // (ZLB send).
 static void controlnull(tunnelidt t)
 {
-	u8 buf[12];
+	uint8_t buf[12];
 	if (tunnel[t].controlc)	// Messages queued; They will carry the ack.
 		return;
 
-	*(u16 *) (buf + 0) = htons(0xC802); // flags/ver
-	*(u16 *) (buf + 2) = htons(12); // length
-	*(u16 *) (buf + 4) = htons(tunnel[t].far); // tunnel
-	*(u16 *) (buf + 6) = htons(0); // session
-	*(u16 *) (buf + 8) = htons(tunnel[t].ns); // sequence
-	*(u16 *) (buf + 10) = htons(tunnel[t].nr); // sequence
+	*(uint16_t *) (buf + 0) = htons(0xC802); // flags/ver
+	*(uint16_t *) (buf + 2) = htons(12); // length
+	*(uint16_t *) (buf + 4) = htons(tunnel[t].far); // tunnel
+	*(uint16_t *) (buf + 6) = htons(0); // session
+	*(uint16_t *) (buf + 8) = htons(tunnel[t].ns); // sequence
+	*(uint16_t *) (buf + 10) = htons(tunnel[t].nr); // sequence
 	tunnelsend(buf, 12, t);
 }
 
 // add a control message to a tunnel, and send if within window
 static void controladd(controlt * c, tunnelidt t, sessionidt s)
 {
-	*(u16 *) (c->buf + 2) = htons(c->length); // length
-	*(u16 *) (c->buf + 4) = htons(tunnel[t].far); // tunnel
-	*(u16 *) (c->buf + 6) = htons(s ? session[s].far : 0); // session
-	*(u16 *) (c->buf + 8) = htons(tunnel[t].ns); // sequence
+	*(uint16_t *) (c->buf + 2) = htons(c->length); // length
+	*(uint16_t *) (c->buf + 4) = htons(tunnel[t].far); // tunnel
+	*(uint16_t *) (c->buf + 6) = htons(s ? session[s].far : 0); // session
+	*(uint16_t *) (c->buf + 8) = htons(tunnel[t].ns); // sequence
 	tunnel[t].ns++;              // advance sequence
 	// link in message in to queue
 	if (tunnel[t].controlc)
@@ -1009,7 +1393,7 @@ void throttle_session(sessionidt s, int rate_in, int rate_out)
 }
 
 // add/remove filters from session (-1 = no change)
-void filter_session(sessionidt s, int filter_in, int filter_out)
+static void filter_session(sessionidt s, int filter_in, int filter_out)
 {
 	if (!session[s].tunnel)
 		return; // No-one home.
@@ -1052,7 +1436,7 @@ void sessionshutdown(sessionidt s, char *reason)
 	int walled_garden = session[s].walled_garden;
 
 
-	CSTAT(call_sessionshutdown);
+	CSTAT(sessionshutdown);
 
 	if (!session[s].tunnel)
 	{
@@ -1070,7 +1454,7 @@ void sessionshutdown(sessionidt s, char *reason)
 	if (session[s].opened && !walled_garden && !session[s].die)
 	{
 		// RADIUS Stop message
-		u16 r = session[s].radius;
+		uint16_t r = session[s].radius;
 		if (!r)
 		{
 			if (!(r = radiusnew(s)))
@@ -1080,9 +1464,7 @@ void sessionshutdown(sessionidt s, char *reason)
 			}
 			else
 			{
-				int n;
-				for (n = 0; n < 15; n++)
-					radius[r].auth[n] = rand();
+				random_data(radius[r].auth, sizeof(radius[r].auth));
 			}
 		}
 
@@ -1115,6 +1497,10 @@ void sessionshutdown(sessionidt s, char *reason)
 		}
 		else
 			free_ip_address(s);
+
+		// unroute IPv6, if setup
+		if (session[s].flags & SF_IPV6_ROUTED)
+			route6set(s, session[s].ipv6route, session[s].ipv6prefixlen, 0);
 	}
 
 	if (session[s].throttle_in || session[s].throttle_out) // Unthrottle if throttled.
@@ -1139,11 +1525,11 @@ void sessionshutdown(sessionidt s, char *reason)
 
 void sendipcp(tunnelidt t, sessionidt s)
 {
-	u8 buf[MAXCONTROL];
-	u16 r = session[s].radius;
-	u8 *q;
+	uint8_t buf[MAXCONTROL];
+	uint16_t r = session[s].radius;
+	uint8_t *q;
 
-	CSTAT(call_sendipcp);
+	CSTAT(sendipcp);
 
 	if (!r)
 		r = radiusnew(s);
@@ -1167,22 +1553,46 @@ void sendipcp(tunnelidt t, sessionidt s)
 
 	*q = ConfigReq;
 	q[1] = r << RADIUS_SHIFT;                    // ID, dont care, we only send one type of request
-	*(u16 *) (q + 2) = htons(10);
+	*(uint16_t *) (q + 2) = htons(10);
 	q[4] = 3;
 	q[5] = 6;
-	*(u32 *) (q + 6) = config->peer_address ? config->peer_address :
-	    		   config->bind_address ? config->bind_address :
-			   my_address; // send my IP
+	*(in_addr_t *) (q + 6) = config->peer_address ? config->peer_address :
+				 config->bind_address ? config->bind_address :
+				 my_address; // send my IP
 
 	tunnelsend(buf, 10 + (q - buf), t); // send it
 	session[s].flags &= ~SF_IPCP_ACKED;	// Clear flag.
+
+	// If we have an IPv6 prefix length configured, assume we should
+	// try to negotiate an IPv6 session as well. Unless we've had a
+	// (N)ACK for IPV6CP.
+	if (config->ipv6_prefix.s6_addr[0] > 0 && 
+			!(session[s].flags & SF_IPV6CP_ACKED) &&
+			!(session[s].flags & SF_IPV6_NACKED))
+	{
+		q = makeppp(buf,sizeof(buf), 0, 0, t, s, PPPIPV6CP);
+		if (!q) return;
+
+		*q = ConfigReq;
+		q[1] = r << RADIUS_SHIFT;		// ID, don't care, we
+							// only send one type
+							// of request
+		*(uint16_t *) (q + 2) = htons(14);
+		q[4] = 1;
+		q[5] = 10;
+		*(uint32_t *) (q + 6) = 0;		// We'll be prefix::1
+		*(uint32_t *) (q + 10) = 0;
+		q[13] = 1;
+
+		tunnelsend(buf, 14 + (q - buf), t);	// send it
+	}
 }
 
 // kill a session now
 static void sessionkill(sessionidt s, char *reason)
 {
 
-	CSTAT(call_sessionkill);
+	CSTAT(sessionkill);
 
 	session[s].die = now();
 	sessionshutdown(s, reason);  // close radius/routes, etc.
@@ -1212,7 +1622,7 @@ static void tunnelkill(tunnelidt t, char *reason)
 	sessionidt s;
 	controlt *c;
 
-	CSTAT(call_tunnelkill);
+	CSTAT(tunnelkill);
 
 	tunnel[t].state = TUNNELDIE;
 
@@ -1242,7 +1652,7 @@ static void tunnelshutdown(tunnelidt t, char *reason)
 {
 	sessionidt s;
 
-	CSTAT(call_tunnelshutdown);
+	CSTAT(tunnelshutdown);
 
 	if (!tunnel[t].last || !tunnel[t].far || tunnel[t].state == TUNNELFREE)
 	{
@@ -1270,14 +1680,14 @@ static void tunnelshutdown(tunnelidt t, char *reason)
 }
 
 // read and process packet on tunnel (UDP)
-void processudp(u8 * buf, int len, struct sockaddr_in *addr)
+void processudp(uint8_t * buf, int len, struct sockaddr_in *addr)
 {
 	char *chapresponse = NULL;
-	u16 l = len, t = 0, s = 0, ns = 0, nr = 0;
-	u8 *p = buf + 2;
+	uint16_t l = len, t = 0, s = 0, ns = 0, nr = 0;
+	uint8_t *p = buf + 2;
 
 
-	CSTAT(call_processudp);
+	CSTAT(processudp);
 
 	udp_rx += len;
 	udp_rx_pkt++;
@@ -1298,12 +1708,12 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 	}
 	if (*buf & 0x40)
 	{                          // length
-		l = ntohs(*(u16 *) p);
+		l = ntohs(*(uint16_t *) p);
 		p += 2;
 	}
-	t = ntohs(*(u16 *) p);
+	t = ntohs(*(uint16_t *) p);
 	p += 2;
-	s = ntohs(*(u16 *) p);
+	s = ntohs(*(uint16_t *) p);
 	p += 2;
 	if (s >= MAXSESSION)
 	{
@@ -1319,36 +1729,36 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 	}
 	if (*buf & 0x08)
 	{                          // ns/nr
-		ns = ntohs(*(u16 *) p);
+		ns = ntohs(*(uint16_t *) p);
 		p += 2;
-		nr = ntohs(*(u16 *) p);
+		nr = ntohs(*(uint16_t *) p);
 		p += 2;
 	}
 	if (*buf & 0x02)
 	{                          // offset
-		u16 o = ntohs(*(u16 *) p);
+		uint16_t o = ntohs(*(uint16_t *) p);
 		p += o + 2;
 	}
 	if ((p - buf) > l)
 	{
-		LOG(1, s, t, "Bad length %d>%d\n", (p - buf), l);
+		LOG(1, s, t, "Bad length %d>%d\n", (int) (p - buf), l);
 		STAT(tunnel_rx_errors);
 		return;
 	}
 	l -= (p - buf);
 	if (*buf & 0x80)
 	{                          // control
-		u16 message = 0xFFFF; // message type
-		u8 fatal = 0;
-		u8 mandatorymessage = 0;
-		u8 chap = 0;      // if CHAP being used
-		u16 asession = 0;  // assigned session
-		u32 amagic = 0;    // magic number
-		u8 aflags = 0;    // flags from last LCF
-		u16 version = 0x0100; // protocol version (we handle 0.0 as well and send that back just in case)
-		int requestchap = 0;	// do we request PAP instead of original CHAP request?
-		char called[MAXTEL] = ""; // called number
-		char calling[MAXTEL] = ""; // calling number
+		uint16_t message = 0xFFFF;	// message type
+		uint8_t fatal = 0;
+		uint8_t mandatorymessage = 0;
+		uint8_t chap = 0;		// if CHAP being used
+		uint16_t asession = 0;		// assigned session
+		uint32_t amagic = 0;		// magic number
+		uint8_t aflags = 0;		// flags from last LCF
+		uint16_t version = 0x0100;	// protocol version (we handle 0.0 as well and send that back just in case)
+		int requestchap = 0;		// do we request PAP instead of original CHAP request?
+		char called[MAXTEL] = "";	// called number
+		char calling[MAXTEL] = "";	// calling number
 
 		if (!config->cluster_iam_master)
 		{
@@ -1374,7 +1784,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 			for (i = 1; i <= config->cluster_highest_tunnelid ; ++i)
 			{
 				if (tunnel[i].state != TUNNELOPENING ||
-					tunnel[i].ip != ntohl(*(ipt *) & addr->sin_addr) ||
+					tunnel[i].ip != ntohl(*(in_addr_t *) & addr->sin_addr) ||
 					tunnel[i].port != ntohs(addr->sin_port) )
 					continue;
 				t = i;
@@ -1396,7 +1806,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 				return;
 			}
 			tunnelclear(t);
-			tunnel[t].ip = ntohl(*(ipt *) & addr->sin_addr);
+			tunnel[t].ip = ntohl(*(in_addr_t *) & addr->sin_addr);
 			tunnel[t].port = ntohs(addr->sin_port);
 			tunnel[t].window = 4; // default window
 			STAT(tunnel_created);
@@ -1469,10 +1879,10 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 			// process AVPs
 			while (l && !(fatal & 0x80))
 			{
-				u16 n = (ntohs(*(u16 *) p) & 0x3FF);
-				u8 *b = p;
-				u8 flags = *p;
-				u16 mtype;
+				uint16_t n = (ntohs(*(uint16_t *) p) & 0x3FF);
+				uint8_t *b = p;
+				uint8_t flags = *p;
+				uint16_t mtype;
 				p += n;       // next
 				if (l < n)
 				{
@@ -1513,48 +1923,43 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					continue; // next
 				}
 				b += 2;
-				if (*(u16 *) (b))
+				if (*(uint16_t *) (b))
 				{
-					LOG(2, s, t, "Unknown AVP vendor %d\n", ntohs(*(u16 *) (b)));
+					LOG(2, s, t, "Unknown AVP vendor %d\n", ntohs(*(uint16_t *) (b)));
 					fatal = flags;
 					continue; // next
 				}
 				b += 2;
-				mtype = ntohs(*(u16 *) (b));
+				mtype = ntohs(*(uint16_t *) (b));
 				b += 2;
 				n -= 6;
 
-				LOG(4, s, t, "   AVP %d (%s) len %d\n", mtype, avpnames[mtype], n);
+				LOG(4, s, t, "   AVP %d (%s) len %d\n", mtype, avp_name(mtype), n);
 				switch (mtype)
 				{
 				case 0:     // message type
-					message = ntohs(*(u16 *) b);
-					LOG(4, s, t, "   Message type = %d (%s)\n", *b, l2tp_message_types[message]);
+					message = ntohs(*(uint16_t *) b);
+					LOG(4, s, t, "   Message type = %d (%s)\n", *b, l2tp_message_type(message));
 					mandatorymessage = flags;
 					break;
 				case 1:     // result code
 					{
-						u16 rescode = ntohs(*(u16 *)(b));
+						uint16_t rescode = ntohs(*(uint16_t *) b);
 						const char* resdesc = "(unknown)";
 						if (message == 4)
 						{ /* StopCCN */
-							if (rescode <= MAX_STOPCCN_RESULT_CODE)
-								resdesc = stopccn_result_codes[rescode];
+							resdesc = stopccn_result_code(rescode);
 						}
 						else if (message == 14)
 						{ /* CDN */
-							if (rescode <= MAX_CDN_RESULT_CODE)
-								resdesc = cdn_result_codes[rescode];
+							resdesc = cdn_result_code(rescode);
 						}
 
 						LOG(4, s, t, "   Result Code %d: %s\n", rescode, resdesc);
 						if (n >= 4)
 						{
-							u16 errcode = ntohs(*(u16 *)(b + 2));
-							const char* errdesc = "(unknown)";
-							if (errcode <= MAX_ERROR_CODE)
-								errdesc = error_codes[errcode];
-							LOG(4, s, t, "   Error Code %d: %s\n", errcode, errdesc);
+							uint16_t errcode = ntohs(*(uint16_t *)(b + 2));
+							LOG(4, s, t, "   Error Code %d: %s\n", errcode, error_code(errcode));
 						}
 						if (n > 4)
 							LOG(4, s, t, "   Error String: %.*s\n", n-4, b+4);
@@ -1564,7 +1969,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					break;
 				case 2:     // protocol version
 					{
-						version = ntohs(*(u16 *) (b));
+						version = ntohs(*(uint16_t *) (b));
 						LOG(4, s, t, "   Protocol version = %d\n", version);
 						if (version && version != 0x0100)
 						{   // allow 0.0 and 1.0
@@ -1599,11 +2004,11 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					LOG(4, s, t, "   Vendor name = \"%s\"\n", tunnel[t].vendor);
 					break;
 				case 9:     // assigned tunnel
-					tunnel[t].far = ntohs(*(u16 *) (b));
+					tunnel[t].far = ntohs(*(uint16_t *) (b));
 					LOG(4, s, t, "   Remote tunnel id = %d\n", tunnel[t].far);
 					break;
 				case 10:    // rx window
-					tunnel[t].window = ntohs(*(u16 *) (b));
+					tunnel[t].window = ntohs(*(uint16_t *) (b));
 					if (!tunnel[t].window)
 						tunnel[t].window = 1; // window of 0 is silly
 					LOG(4, s, t, "   rx window = %d\n", tunnel[t].window);
@@ -1620,18 +2025,18 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					break;
 
 				case 14:    // assigned session
-					asession = session[s].far = ntohs(*(u16 *) (b));
+					asession = session[s].far = ntohs(*(uint16_t *) (b));
 					LOG(4, s, t, "   assigned session = %d\n", asession);
 					break;
 				case 15:    // call serial number
-					LOG(4, s, t, "   call serial number = %d\n", ntohl(*(u32 *)b));
+					LOG(4, s, t, "   call serial number = %d\n", ntohl(*(uint32_t *)b));
 					break;
 				case 18:    // bearer type
-					LOG(4, s, t, "   bearer type = %d\n", ntohl(*(u32 *)b));
+					LOG(4, s, t, "   bearer type = %d\n", ntohl(*(uint32_t *)b));
 					// TBA - for RADIUS
 					break;
 				case 19:    // framing type
-					LOG(4, s, t, "   framing type = %d\n", ntohl(*(u32 *)b));
+					LOG(4, s, t, "   framing type = %d\n", ntohl(*(uint32_t *)b));
 					// TBA
 					break;
 				case 21:    // called number
@@ -1649,7 +2054,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 				case 24:    // tx connect speed
 					if (n == 4)
 					{
-						session[s].tx_connect_speed = ntohl(*(u32 *)b);
+						session[s].tx_connect_speed = ntohl(*(uint32_t *)b);
 					}
 					else
 					{
@@ -1663,7 +2068,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 				case 38:    // rx connect speed
 					if (n == 4)
 					{
-						session[s].rx_connect_speed = ntohl(*(u32 *)b);
+						session[s].rx_connect_speed = ntohl(*(uint32_t *)b);
 					}
 					else
 					{
@@ -1676,15 +2081,15 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					break;
 				case 25:    // Physical Channel ID
 					{
-						u32 tmp = ntohl(*(u32 *)b);
+						uint32_t tmp = ntohl(*(uint32_t *) b);
 						LOG(4, s, t, "   Physical Channel ID <%X>\n", tmp);
 						break;
 					}
 				case 29:    // Proxy Authentication Type
 					{
-						u16 authtype = ntohs(*(u16 *)b);
-						LOG(4, s, t, "   Proxy Auth Type %d (%s)\n", authtype, authtypes[authtype]);
-						requestchap = (authtype == 2);
+						uint16_t atype = ntohs(*(uint16_t *)b);
+						LOG(4, s, t, "   Proxy Auth Type %d (%s)\n", atype, auth_type(atype));
+						requestchap = (atype == 2);
 						break;
 					}
 				case 30:    // Proxy Authentication Name
@@ -1703,7 +2108,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					}
 				case 32:    // Proxy Authentication ID
 					{
-						u16 authid = ntohs(*(u16 *)(b));
+						uint16_t authid = ntohs(*(uint16_t *)(b));
 						LOG(4, s, t, "   Proxy Auth ID (%d)\n", authid);
 						if (session[s].radius)
 							radius[session[s].radius].id = authid;
@@ -1718,12 +2123,12 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					}
 				case 27:    // last send lcp
 					{        // find magic number
-						u8 *p = b, *e = p + n;
+						uint8_t *p = b, *e = p + n;
 						while (p + 1 < e && p[1] && p + p[1] <= e)
 						{
 							if (*p == 5 && p[1] == 6) // Magic-Number
-								amagic = ntohl(*(u32 *) (p + 2));
-							else if (*p == 3 && p[1] == 5 && *(u16 *) (p + 2) == htons(PPPCHAP) && p[4] == 5) // Authentication-Protocol
+								amagic = ntohl(*(uint32_t *) (p + 2));
+							else if (*p == 3 && p[1] == 5 && *(uint16_t *) (p + 2) == htons(PPPCHAP) && p[4] == 5) // Authentication-Protocol
 								chap = 1;
 							else if (*p == 7) // Protocol-Field-Compression
 								aflags |= SESSIONPFC;
@@ -1801,7 +2206,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 					}
 					else
 					{
-						u16 r;
+						uint16_t r;
 						controlt *c;
 
 						s = sessionfree;
@@ -1828,12 +2233,9 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 						LOG(3, s, t, "New session (%d/%d)\n", tunnel[t].far, session[s].far);
 						control16(c, 14, s, 1); // assigned session
 						controladd(c, t, s); // send the reply
-						{
-							// Generate a random challenge
-							int n;
-							for (n = 0; n < 15; n++)
-								radius[r].auth[n] = rand();
-						}
+
+						// Generate a random challenge
+						random_data(radius[r].auth, sizeof(radius[r].auth));
 						strncpy(radius[r].calling, calling, sizeof(radius[r].calling) - 1);
 						strncpy(session[s].called, called, sizeof(session[s].called) - 1);
 						strncpy(session[s].calling, calling, sizeof(session[s].calling) - 1);
@@ -1878,7 +2280,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 	}
 	else
 	{                          // data
-		u16 prot;
+		uint16_t prot;
 
 		LOG_HEX(5, "Receive Tunnel Data", p, l);
 		if (l > 2 && p[0] == 0xFF && p[1] == 0x03)
@@ -1899,7 +2301,7 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 		}
 		else
 		{
-			prot = ntohs(*(u16 *) p);
+			prot = ntohs(*(uint16_t *) p);
 			p += 2;
 			l -= 2;
 		}
@@ -1945,6 +2347,19 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 			if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
 			processipcp(t, s, p, l);
 		}
+		else if (prot == PPPIPV6CP)
+		{
+			if (config->ipv6_prefix.s6_addr[0] > 0)
+			{
+				session[s].last_packet = time_now;
+				if (!config->cluster_iam_master) { master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port); return; }
+				processipv6cp(t, s, p, l);
+			}
+			else
+			{
+				LOG(1, s, t, "IPv6 not configured; ignoring IPv6CP\n");
+			}
+		}
 		else if (prot == PPPCCP)
 		{
 			session[s].last_packet = time_now;
@@ -1968,6 +2383,28 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 
 			processipin(t, s, p, l);
 		}
+		else if (prot == PPPIPV6)
+		{
+			if (!config->ipv6_prefix.s6_addr[0] > 0)
+			{
+				LOG(1, s, t, "IPv6 not configured; yet received IPv6 packet. Ignoring.\n");
+				return;
+			}
+			if (session[s].die)
+			{
+				LOG(4, s, t, "Session %d is closing.  Don't process PPP packets\n", s);
+				return;              // closing session, PPP not processed
+			}
+
+			session[s].last_packet = time_now;
+			if (session[s].walled_garden && !config->cluster_iam_master)
+			{
+				master_forward_packet(buf, len, addr->sin_addr.s_addr, addr->sin_port);
+				return;
+			}
+
+			processipv6in(t, s, p, l);
+		}
 		else
 		{
 			STAT(tunnel_rx_errors);
@@ -1977,13 +2414,13 @@ void processudp(u8 * buf, int len, struct sockaddr_in *addr)
 }
 
 // read and process packet on tun
-static void processtun(u8 * buf, int len)
+static void processtun(uint8_t * buf, int len)
 {
 	LOG_HEX(5, "Receive TUN Data", buf, len);
 	STAT(tun_rx_packets);
 	INC_STAT(tun_rx_bytes, len);
 
-	CSTAT(call_processtun);
+	CSTAT(processtun);
 
 	eth_rx_pkt++;
 	eth_rx += len;
@@ -1994,8 +2431,12 @@ static void processtun(u8 * buf, int len)
 		return;
 	}
 
-	if (*(u16 *) (buf + 2) == htons(PKTIP)) // IP
+	if (*(uint16_t *) (buf + 2) == htons(PKTIP)) // IPv4
 		processipout(buf, len);
+	else if (*(uint16_t *) (buf + 2) == htons(PKTIPV6) // IPV6
+	    && config->ipv6_prefix.s6_addr[0] > 0)
+		processipv6out(buf, len);
+
 	// Else discard.
 }
 
@@ -2010,7 +2451,7 @@ static int regular_cleanups(void)
 	static sessionidt s = 0;	// Next session to check for actions on.
 	tunnelidt t;
 	int count=0,i;
-	u16 r;
+	uint16_t r;
 	static clockt next_acct = 0;
 	static clockt next_shut_acct = 0;
 	int a;
@@ -2044,7 +2485,7 @@ static int regular_cleanups(void)
 			if (tunnel[t].retry <= TIME)
 			{
 				controlt *c = tunnel[t].controls;
-				u8 w = tunnel[t].window;
+				uint8_t w = tunnel[t].window;
 				tunnel[t].try++; // another try
 				if (tunnel[t].try > 5)
 					tunnelkill(t, "Timeout on control message"); // game over
@@ -2114,15 +2555,15 @@ static int regular_cleanups(void)
 		// No data in IDLE_TIMEOUT seconds, send LCP ECHO
 		if (session[s].user[0] && (time_now - session[s].last_packet >= ECHO_TIMEOUT))
 		{
-			u8 b[MAXCONTROL] = {0};
+			uint8_t b[MAXCONTROL] = {0};
 
-			u8 *q = makeppp(b, sizeof(b), 0, 0, session[s].tunnel, s, PPPLCP);
+			uint8_t *q = makeppp(b, sizeof(b), 0, 0, session[s].tunnel, s, PPPLCP);
 			if (!q) continue;
 
 			*q = EchoReq;
-			*(u8 *)(q + 1) = (time_now % 255); // ID
-			*(u16 *)(q + 2) = htons(8); // Length
-			*(u32 *)(q + 4) = 0; // Magic Number (not supported)
+			*(uint8_t *)(q + 1) = (time_now % 255); // ID
+			*(uint16_t *)(q + 2) = htons(8); // Length
+			*(uint32_t *)(q + 4) = 0; // Magic Number (not supported)
 
 			LOG(4, s, session[s].tunnel, "No data in %d seconds, sending LCP ECHO\n",
 					(int)(time_now - session[s].last_packet));
@@ -2283,7 +2724,7 @@ static int readset_n = 0;
 static void mainloop(void)
 {
 	int i;
-	u8 buf[65536];
+	uint8_t buf[65536];
 	struct timeval to;
 	clockt next_cluster_ping = 0;	// send initial ping immediately
 	time_t next_clean = time_now + config->cleanup_interval;
@@ -2347,6 +2788,8 @@ static void mainloop(void)
 		n = select(n + 1, &r, 0, 0, &to);
 #endif /* BGP */
 
+		STAT(select_called);
+
 		TIME = now();
 		if (n < 0)
 		{
@@ -2362,6 +2805,9 @@ static void mainloop(void)
 		{
 			struct sockaddr_in addr;
 			int alen, c, s;
+			int udp_pkts = 0;
+			int tun_pkts = 0;
+			int cluster_pkts = 0;
 
 			// nsctl commands
 			if (FD_ISSET(controlfd, &r))
@@ -2421,6 +2867,7 @@ static void mainloop(void)
 					if ((s = recvfrom(udpfd, buf, sizeof(buf), 0, (void *) &addr, &alen)) > 0)
 					{
 						processudp(buf, s, &addr);
+						udp_pkts++;
 					}
 					else
 					{
@@ -2435,6 +2882,7 @@ static void mainloop(void)
 					if ((s = read(tunfd, buf, sizeof(buf))) > 0)
 					{
 						processtun(buf, s);
+					    	tun_pkts++;
 					}
 					else
 					{
@@ -2450,6 +2898,7 @@ static void mainloop(void)
 					if ((s = recvfrom(cluster_sockfd, buf, sizeof(buf), MSG_WAITALL, (void *) &addr, &alen)) > 0)
 					{
 						processcluster(buf, s, addr.sin_addr.s_addr);
+						cluster_pkts++;
 					}
 					else
 					{
@@ -2458,6 +2907,17 @@ static void mainloop(void)
 					}
 				}
 			}
+
+			if (udp_pkts > 1 || tun_pkts > 1 || cluster_pkts > 1)
+				STAT(multi_read_used);
+
+			if (c >= config->multi_read_count)
+			{
+				LOG(3, 0, 0, "Reached multi_read_count (%d); processed %d udp, %d tun and %d cluster packets\n",
+					config->multi_read_count, udp_pkts, tun_pkts, cluster_pkts);
+
+				STAT(multi_read_exceeded);
+			}
 		}
 
 			// Runs on every machine (master and slaves).
@@ -2607,6 +3067,7 @@ static void initdata(int optdebug, char *optconfig)
 	config->debug = optdebug;
 	config->num_tbfs = MAXTBFS;
 	config->rl_rate = 28; // 28kbps
+	strcpy(config->random_device, RANDOMDEVICE);
 
 	if (!(tunnel = shared_malloc(sizeof(tunnelt) * MAXTUNNEL)))
 	{
@@ -2619,9 +3080,9 @@ static void initdata(int optdebug, char *optconfig)
 		exit(1);
 	}
 
-	if (!(sess_count = shared_malloc(sizeof(sessioncountt) * MAXSESSION)))
+	if (!(sess_local = shared_malloc(sizeof(sessionlocalt) * MAXSESSION)))
 	{
-		LOG(0, 0, 0, "Error doing malloc for sessions_count: %s\n", strerror(errno));
+		LOG(0, 0, 0, "Error doing malloc for sess_local: %s\n", strerror(errno));
 		exit(1);
 	}
 
@@ -2637,12 +3098,12 @@ static void initdata(int optdebug, char *optconfig)
 		exit(1);
 	}
 
-if (!(ip_filters = shared_malloc(sizeof(ip_filtert) * MAXFILTER)))
-{
-	LOG(0, 0, 0, "Error doing malloc for ip_filters: %s\n", strerror(errno));
-	exit(1);
-}
-memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER);
+	if (!(ip_filters = shared_malloc(sizeof(ip_filtert) * MAXFILTER)))
+	{
+		LOG(0, 0, 0, "Error doing malloc for ip_filters: %s\n", strerror(errno));
+		exit(1);
+	}
+	memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER);
 
 #ifdef RINGBUFFER
 	if (!(ringbuffer = shared_malloc(sizeof(struct Tringbuffer))))
@@ -2673,7 +3134,7 @@ memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER);
 	memset(ip_address_pool, 0, sizeof(ippoolt) * MAXIPPOOL);
 
 		// Put all the sessions on the free list marked as undefined.
-	for (i = 1; i < MAXSESSION - 1; i++)
+	for (i = 1; i < MAXSESSION; i++)
 	{
 		session[i].next = i + 1;
 		session[i].tunnel = T_UNDEF;	// mark it as not filled in.
@@ -2682,7 +3143,7 @@ memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER);
 	sessionfree = 1;
 
 		// Mark all the tunnels as undefined (waiting to be filled in by a download).
-	for (i = 1; i < MAXTUNNEL- 1; i++)
+	for (i = 1; i < MAXTUNNEL; i++)
 		tunnel[i].state = TUNNELUNDEF;	// mark it as not filled in.
 
 	if (!*hostname)
@@ -2705,14 +3166,14 @@ memset(ip_filters, 0, sizeof(ip_filtert) * MAXFILTER);
 
 static int assign_ip_address(sessionidt s)
 {
-	u32 i;
+	uint32_t i;
 	int best = -1;
 	time_t best_time = time_now;
 	char *u = session[s].user;
 	char reuse = 0;
 
 
-	CSTAT(call_assign_ip_address);
+	CSTAT(assign_ip_address);
 
 	for (i = 1; i < ip_pool_size; i++)
 	{
@@ -2765,7 +3226,7 @@ static void free_ip_address(sessionidt s)
 	int i = session[s].ip_pool_index;
 
 
-	CSTAT(call_free_ip_address);
+	CSTAT(free_ip_address);
 
 	if (!session[s].ip)
 		return; // what the?
@@ -2866,7 +3327,7 @@ static void fix_address_pool(int sid)
 //
 // Add a block of addresses to the IP pool to hand out.
 //
-static void add_to_ip_pool(u32 addr, u32 mask)
+static void add_to_ip_pool(in_addr_t addr, in_addr_t mask)
 {
 	int i;
 	if (mask == 0)
@@ -2917,7 +3378,7 @@ static void initippool()
 		if ((p = (char *)strrchr(buf, '\n'))) *p = 0;
 		if ((p = (char *)strchr(buf, ':')))
 		{
-			ipt src;
+			in_addr_t src;
 			*p = '\0';
 			src = inet_addr(buf);
 			if (src == INADDR_NONE)
@@ -2935,7 +3396,7 @@ static void initippool()
 		{
 			// It's a range
 			int numbits = 0;
-			u32 start = 0, mask = 0;
+			in_addr_t start = 0, mask = 0;
 
 			LOG(2, 0, 0, "Adding IP address range %s\n", buf);
 			*p++ = 0;
@@ -2945,7 +3406,7 @@ static void initippool()
 				continue;
 			}
 			start = ntohl(inet_addr(pool));
-			mask = (u32)(pow(2, numbits) - 1) << (32 - numbits);
+			mask = (in_addr_t) (pow(2, numbits) - 1) << (32 - numbits);
 
 			// Add a static route for this pool
 			LOG(5, 0, 0, "Adding route for address pool %s/%u\n",
@@ -2965,7 +3426,7 @@ static void initippool()
 	LOG(1, 0, 0, "IP address pool is %d addresses\n", ip_pool_size - 1);
 }
 
-void snoop_send_packet(char *packet, u16 size, ipt destination, u16 port)
+void snoop_send_packet(char *packet, uint16_t size, in_addr_t destination, uint16_t port)
 {
 	struct sockaddr_in snoop_addr = {0};
 	if (!destination || !port || snoopfd <= 0 || size <= 0 || !packet)
@@ -2975,8 +3436,8 @@ void snoop_send_packet(char *packet, u16 size, ipt destination, u16 port)
 	snoop_addr.sin_addr.s_addr = destination;
 	snoop_addr.sin_port = ntohs(port);
 
-	LOG(5, 0, 0, "Snooping packet at %p (%d bytes) to %s:%d\n",
-		packet, size, fmtaddr(snoop_addr.sin_addr.s_addr, 0),
+	LOG(5, 0, 0, "Snooping %d byte packet to %s:%d\n", size,
+		fmtaddr(snoop_addr.sin_addr.s_addr, 0),
 		htons(snoop_addr.sin_port));
 
 	if (sendto(snoopfd, packet, size, MSG_DONTWAIT | MSG_NOSIGNAL, (void *) &snoop_addr, sizeof(snoop_addr)) < 0)
@@ -3021,8 +3482,8 @@ static int dump_session(FILE **f, sessiont *s)
 		s->user,						// username
 		fmtaddr(htonl(s->ip), 0),				// ip
 		(s->throttle_in || s->throttle_out) ? 2 : 1,		// qos
-		(u32) s->cin,						// uptxoctets
-		(u32) s->cout);						// downrxoctets
+		(uint32_t) s->cin,					// uptxoctets
+		(uint32_t) s->cout);					// downrxoctets
 
 	s->pin = s->cin = 0;
 	s->pout = s->cout = 0;
@@ -3036,7 +3497,7 @@ static void dump_acct_info(int all)
 	FILE *f = NULL;
 
 
-	CSTAT(call_dump_acct_info);
+	CSTAT(dump_acct_info);
 
 	if (shut_acct_n)
 	{
@@ -3110,7 +3571,7 @@ int main(int argc, char *argv[])
 	init_tbf(config->num_tbfs);
 
 	LOG(0, 0, 0, "L2TPNS version " VERSION "\n");
-	LOG(0, 0, 0, "Copyright (c) 2003, 2004 Optus Internet Engineering\n");
+	LOG(0, 0, 0, "Copyright (c) 2003, 2004, 2005 Optus Internet Engineering\n");
 	LOG(0, 0, 0, "Copyright (c) 2002 FireBrick (Andrews & Arnold Ltd / Watchfront Ltd) - GPL licenced\n");
 	{
 		struct rlimit rlim;
@@ -3173,8 +3634,6 @@ int main(int argc, char *argv[])
 	initrad();
 	initippool();
 
-	read_state();
-
 	signal(SIGHUP, sighup_handler);
 	signal(SIGTERM, sigterm_handler);
 	signal(SIGINT, sigterm_handler);
@@ -3266,9 +3725,6 @@ static void sigalrm_handler(int sig)
 static void sigterm_handler(int sig)
 {
 	LOG(1, 0, 0, "Shutting down cleanly\n");
-	if (config->save_state)
-		dump_state();
-
 	main_quit++;
 }
 
@@ -3301,183 +3757,7 @@ static void sigchild_handler(int sig)
 	    ;
 }
 
-static void read_state()
-{
-	struct stat sb;
-	int i;
-	ippoolt itmp;
-	FILE *f;
-	char magic[sizeof(DUMP_MAGIC) - 1];
-	u32 buf[2];
-
-	if (!config->save_state)
-	{
-		unlink(STATEFILE);
-		return ;
-	}
-
-	if (stat(STATEFILE, &sb) < 0)
-	{
-		unlink(STATEFILE);
-		return ;
-	}
-
-	if (sb.st_mtime < (time(NULL) - 60))
-	{
-		LOG(0, 0, 0, "State file is too old to read, ignoring\n");
-		unlink(STATEFILE);
-		return ;
-	}
-
-	f = fopen(STATEFILE, "r");
-	unlink(STATEFILE);
-
-	if (!f)
-	{
-		LOG(0, 0, 0, "Can't read state file: %s\n", strerror(errno));
-		exit(1);
-	}
-
-	if (fread(magic, sizeof(magic), 1, f) != 1 || strncmp(magic, DUMP_MAGIC, sizeof(magic)))
-	{
-		LOG(0, 0, 0, "Bad state file magic\n");
-		exit(1);
-	}
-
-	LOG(1, 0, 0, "Reading state information\n");
-	if (fread(buf, sizeof(buf), 1, f) != 1 || buf[0] > MAXIPPOOL || buf[1] != sizeof(ippoolt))
-	{
-		LOG(0, 0, 0, "Error/mismatch reading ip pool header from state file\n");
-		exit(1);
-	}
-
-	if (buf[0] > ip_pool_size)
-	{
-		LOG(0, 0, 0, "ip pool has shrunk!  state = %d, current = %d\n", buf[0], ip_pool_size);
-		exit(1);
-	}
-
-	LOG(2, 0, 0, "Loading %u ip addresses\n", buf[0]);
-	for (i = 0; i < buf[0]; i++)
-	{
-		if (fread(&itmp, sizeof(itmp), 1, f) != 1)
-		{
-			LOG(0, 0, 0, "Error reading ip %d from state file: %s\n", i, strerror(errno));
-			exit(1);
-		}
-
-		if (itmp.address != ip_address_pool[i].address)
-		{
-			LOG(0, 0, 0, "Mismatched ip %d from state file: pool may only be extended\n", i);
-			exit(1);
-		}
-
-		memcpy(&ip_address_pool[i], &itmp, sizeof(itmp));
-	}
-
-	if (fread(buf, sizeof(buf), 1, f) != 1 || buf[0] != MAXTUNNEL || buf[1] != sizeof(tunnelt))
-	{
-		LOG(0, 0, 0, "Error/mismatch reading tunnel header from state file\n");
-		exit(1);
-	}
-
-	LOG(2, 0, 0, "Loading %u tunnels\n", MAXTUNNEL);
-	if (fread(tunnel, sizeof(tunnelt), MAXTUNNEL, f) != MAXTUNNEL)
-	{
-		LOG(0, 0, 0, "Error reading tunnel data from state file\n");
-		exit(1);
-	}
-
-	for (i = 0; i < MAXTUNNEL; i++)
-	{
-		tunnel[i].controlc = 0;
-		tunnel[i].controls = NULL;
-		tunnel[i].controle = NULL;
-		if (*tunnel[i].hostname)
-			LOG(3, 0, 0, "Created tunnel for %s\n", tunnel[i].hostname);
-	}
-
-	if (fread(buf, sizeof(buf), 1, f) != 1 || buf[0] != MAXSESSION || buf[1] != sizeof(sessiont))
-	{
-		LOG(0, 0, 0, "Error/mismatch reading session header from state file\n");
-		exit(1);
-	}
-
-	LOG(2, 0, 0, "Loading %u sessions\n", MAXSESSION);
-	if (fread(session, sizeof(sessiont), MAXSESSION, f) != MAXSESSION)
-	{
-		LOG(0, 0, 0, "Error reading session data from state file\n");
-		exit(1);
-	}
-
-	for (i = 0; i < MAXSESSION; i++)
-	{
-		session[i].tbf_in = 0;
-		session[i].tbf_out = 0;
-		if (session[i].opened)
-		{
-			LOG(2, i, 0, "Loaded active session for user %s\n", session[i].user);
-			if (session[i].ip)
-				sessionsetup(session[i].tunnel, i);
-		}
-	}
-
-	fclose(f);
-	LOG(0, 0, 0, "Loaded saved state information\n");
-}
-
-static void dump_state()
-{
-	FILE *f;
-	u32 buf[2];
-
-	if (!config->save_state)
-		return;
-
-	do
-	{
-		if (!(f = fopen(STATEFILE, "w")))
-			break;
-
-		LOG(1, 0, 0, "Dumping state information\n");
-
-		if (fwrite(DUMP_MAGIC, sizeof(DUMP_MAGIC) - 1, 1, f) != 1)
-			break;
-
-		LOG(2, 0, 0, "Dumping %u ip addresses\n", ip_pool_size);
-		buf[0] = ip_pool_size;
-		buf[1] = sizeof(ippoolt);
-		if (fwrite(buf, sizeof(buf), 1, f) != 1)
-			break;
-		if (fwrite(ip_address_pool, sizeof(ippoolt), ip_pool_size, f) != ip_pool_size)
-			break;
-
-		LOG(2, 0, 0, "Dumping %u tunnels\n", MAXTUNNEL);
-		buf[0] = MAXTUNNEL;
-		buf[1] = sizeof(tunnelt);
-		if (fwrite(buf, sizeof(buf), 1, f) != 1)
-			break;
-		if (fwrite(tunnel, sizeof(tunnelt), MAXTUNNEL, f) != MAXTUNNEL)
-			break;
-
-		LOG(2, 0, 0, "Dumping %u sessions\n", MAXSESSION);
-		buf[0] = MAXSESSION;
-		buf[1] = sizeof(sessiont);
-		if (fwrite(buf, sizeof(buf), 1, f) != 1)
-			break;
-		if (fwrite(session, sizeof(sessiont), MAXSESSION, f) != MAXSESSION)
-			break;
-
-		if (fclose(f) == 0)
-			return ; // OK
-	}
-	while (0);
-
-	LOG(0, 0, 0, "Can't write state information: %s\n", strerror(errno));
-	unlink(STATEFILE);
-}
-
-static void build_chap_response(char *challenge, u8 id, u16 challenge_length, char **challenge_response)
+static void build_chap_response(char *challenge, uint8_t id, uint16_t challenge_length, char **challenge_response)
 {
 	MD5_CTX ctx;
 	*challenge_response = NULL;
@@ -3515,6 +3795,7 @@ static int facility_value(char *name)
 static void update_config()
 {
 	int i;
+	char *p;
 	static int timeout = 0;
 	static int interval = 0;
 
@@ -3526,6 +3807,7 @@ static void update_config()
 		fclose(log_stream);
 		log_stream = NULL;
 	}
+
 	if (*config->log_filename)
 	{
 		if (strstr(config->log_filename, "syslog:") == config->log_filename)
@@ -3557,7 +3839,6 @@ static void update_config()
 		setbuf(log_stream, NULL);
 	}
 
-
 	// Update radius
 	config->numradiusservers = 0;
 	for (i = 0; i < MAXRADSERVER; i++)
@@ -3582,6 +3863,59 @@ static void update_config()
 
 	config->num_radfds = 2 << RADIUS_SHIFT;
 
+	// parse radius_authtypes_s
+	config->radius_authtypes = config->radius_authprefer = 0;
+	p = config->radius_authtypes_s;
+	while (*p)
+	{
+		char *s = strpbrk(p, " \t,");
+		int type = 0;
+
+		if (s)
+		{
+			*s++ = 0;
+			while (*s == ' ' || *s == '\t')
+				s++;
+
+			if (!*s)
+				s = 0;
+		}
+
+		if (!strncasecmp("chap", p, strlen(p)))
+			type = AUTHCHAP;
+		else if (!strncasecmp("pap", p, strlen(p)))
+			type = AUTHPAP;
+		else
+			LOG(0, 0, 0, "Invalid RADIUS authentication type \"%s\"", p);
+
+		config->radius_authtypes |= type;
+		if (!config->radius_authprefer)
+			config->radius_authprefer = type;
+	}
+
+	if (!config->radius_authtypes)
+	{
+		LOG(0, 0, 0, "Defaulting to PAP authentication\n");
+		config->radius_authtypes = config->radius_authprefer = AUTHPAP;
+	}
+
+	// normalise radius_authtypes_s
+	if (config->radius_authprefer == AUTHPAP)
+	{
+		strcpy(config->radius_authtypes_s, "pap");
+		if (config->radius_authtypes & AUTHCHAP)
+			strcat(config->radius_authtypes_s, ", chap");
+	}
+	else
+	{
+		strcpy(config->radius_authtypes_s, "chap");
+		if (config->radius_authtypes & AUTHPAP)
+			strcat(config->radius_authtypes_s, ", pap");
+	}
+
+	// re-initialise the random number source
+	initrandom(config->random_device);
+
 	// Update plugins
 	for (i = 0; i < MAXPLUGINS; i++)
 	{
@@ -3599,6 +3933,7 @@ static void update_config()
 			remove_plugin(config->old_plugins[i]);
 		}
 	}
+
 	memcpy(config->old_plugins, config->plugins, sizeof(config->plugins));
 	if (!config->cleanup_interval) config->cleanup_interval = 10;
 	if (!config->multi_read_count) config->multi_read_count = 10;
@@ -3672,12 +4007,12 @@ static void read_config_file()
 int sessionsetup(tunnelidt t, sessionidt s)
 {
 	// A session now exists, set it up
-	ipt ip;
+	in_addr_t ip;
 	char *user;
 	sessionidt i;
 	int r;
 
-	CSTAT(call_sessionsetup);
+	CSTAT(sessionsetup);
 
 	LOG(3, s, t, "Doing session setup for session\n");
 
@@ -3730,6 +4065,7 @@ int sessionsetup(tunnelidt t, sessionidt s)
 		// convered by a Framed-Route.  Anything else is part
 		// of the IP address pool and is already routed, it
 		// just needs to be added to the IP cache.
+		// IPv6 route setup is done in ppp.c, when IPV6CP is acked.
 		if (session[s].ip_pool_index == -1) // static ip
 		{
 			if (!routed) routeset(s, session[s].ip, 0, 0, 1);
@@ -3852,6 +4188,10 @@ int load_session(sessionidt s, sessiont *new)
 		}
 	}
 
+	// check v6 routing
+	if (new->flags & SF_IPV6_ROUTED && !(session[s].flags & SF_IPV6_ROUTED))
+		    route6set(s, new->ipv6route, new->ipv6prefixlen, 1);
+
 	// check filters
 	if (new->filter_in && (new->filter_in > MAXFILTER || !ip_filters[new->filter_in - 1].name[0]))
 	{
@@ -3881,8 +4221,8 @@ int load_session(sessionidt s, sessiont *new)
 					// for walking the sessions to forward byte counts to the master.
 		config->cluster_highest_sessionid = s;
 
-	// TEMP: old session struct used a u32 to define the throttle
-	// speed for both up/down, new uses a u16 for each.  Deal with
+	// TEMP: old session struct used a uint32_t to define the throttle
+	// speed for both up/down, new uses a uint16_t for each.  Deal with
 	// sessions from an old master for migration.
 	if (new->throttle_out == 0 && new->tbf_out)
 		new->throttle_out = new->throttle_in;
@@ -4071,7 +4411,7 @@ static void plugins_done()
 		run_plugin_done(p);
 }
 
-static void processcontrol(u8 * buf, int len, struct sockaddr_in *addr, int alen)
+static void processcontrol(uint8_t * buf, int len, struct sockaddr_in *addr, int alen)
 {
 	struct nsctl request;
 	struct nsctl response;
@@ -4383,16 +4723,16 @@ int cmd_show_hist_open(struct cli_def *cli, char *command, char **argv, int argc
  *
  * Based on code from rp-l2tpd by Roaring Penguin Software Inc.
  */
-static int unhide_avp(u8 *avp, tunnelidt t, sessionidt s, u16 length)
+static int unhide_avp(uint8_t *avp, tunnelidt t, sessionidt s, uint16_t length)
 {
 	MD5_CTX ctx;
-	u8 *cursor;
-	u8 digest[16];
-	u8 working_vector[16];
+	uint8_t *cursor;
+	uint8_t digest[16];
+	uint8_t working_vector[16];
 	uint16_t hidden_length;
-	u8 type[2];
+	uint8_t type[2];
 	size_t done, todo;
-	u8 *output;
+	uint8_t *output;
 
 	// Find the AVP type.
 	type[0] = *(avp + 4);
@@ -4447,7 +4787,7 @@ static int unhide_avp(u8 *avp, tunnelidt t, sessionidt s, u16 length)
 	return hidden_length + 6;
 }
 
-static int ip_filter_port(ip_filter_portt *p, portt port)
+static int ip_filter_port(ip_filter_portt *p, uint16_t port)
 {
 	switch (p->op)
 	{
@@ -4461,7 +4801,7 @@ static int ip_filter_port(ip_filter_portt *p, portt port)
 	return 0;
 }
 
-static int ip_filter_flag(u8 op, u8 sflags, u8 cflags, u8 flags)
+static int ip_filter_flag(uint8_t op, uint8_t sflags, uint8_t cflags, uint8_t flags)
 {
 	switch (op)
 	{
@@ -4478,15 +4818,15 @@ static int ip_filter_flag(u8 op, u8 sflags, u8 cflags, u8 flags)
 	return 0;
 }
 
-int ip_filter(u8 *buf, int len, u8 filter)
+int ip_filter(uint8_t *buf, int len, uint8_t filter)
 {
-	u16 frag_offset;
-	u8 proto;
-    	ipt src_ip;
-	ipt dst_ip;
-	portt src_port = 0;
-	portt dst_port = 0;
-	u8 flags = 0;
+	uint16_t frag_offset;
+	uint8_t proto;
+    	in_addr_t src_ip;
+	in_addr_t dst_ip;
+	uint16_t src_port = 0;
+	uint16_t dst_port = 0;
+	uint8_t flags = 0;
 	ip_filter_rulet *rule;
 
     	if (len < 20) // up to end of destination address
@@ -4495,10 +4835,10 @@ int ip_filter(u8 *buf, int len, u8 filter)
 	if ((*buf >> 4) != 4) // IPv4
 		return 0;
 
-	frag_offset = ntohs(*(u16 *) (buf + 6)) & 0x1fff;
+	frag_offset = ntohs(*(uint16_t *) (buf + 6)) & 0x1fff;
 	proto = buf[9];
-	src_ip = *(u32 *) (buf + 12);
-	dst_ip = *(u32 *) (buf + 16);
+	src_ip = *(in_addr_t *) (buf + 12);
+	dst_ip = *(in_addr_t *) (buf + 16);
 
 	if (frag_offset == 0 && (proto == IPPROTO_TCP || proto == IPPROTO_UDP))
 	{
@@ -4506,8 +4846,8 @@ int ip_filter(u8 *buf, int len, u8 filter)
 		if (len < l + 4) // ports
 			return 0;
 
-		src_port = ntohs(*(u16 *) (buf + l));
-		dst_port = ntohs(*(u16 *) (buf + l + 2));
+		src_port = ntohs(*(uint16_t *) (buf + l));
+		dst_port = ntohs(*(uint16_t *) (buf + l + 2));
 		if (proto == IPPROTO_TCP)
 		{
 		    	if (len < l + 14) // flags