/* This file is part of Netsukuku
 * (c) Copyright 2005 Andrea Lo Pumo aka AlpT <alpt@freaknet.org>
 *
 * This source code is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published 
 * by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * This source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * Please refer to the GNU Public License for more details.
 *
 * You should have received a copy of the GNU Public License along with
 * this source code; if not, write to:
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * - 
 *
 * Various parts are ripped from iproute2/iproute.c
 * written by Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>.
 */

#include "includes.h"

#include "if.h"
#include "libnetlink.h"
#include "inet.h"
#include "krnl_route.h"
#include "libnetlink.h"
#include "ll_map.h"
#include "common.h"

#ifdef LINUX_2_6_14
#include <linux/ip_mp_alg.h>
#define NTK_MULTIPATH_ALGO IP_MP_ALG_WRANDOM
#endif

static struct {
	int tb;
	int flushed;
	char *flushb;
	int flushp;
	int flushe;
	struct rtnl_handle *rth;
	int protocol, protocolmask;
	int scope, scopemask;
	int type, typemask;
	int tos, tosmask;
	int iif, iifmask;
	int oif, oifmask;
	int realm, realmmask;
	inet_prefix rprefsrc;
	inet_prefix rvia;
	inet_prefix rdst;
	inet_prefix mdst;
	inet_prefix rsrc;
	inet_prefix msrc;
} filter;

void
route_reset_filter()
{
	setzero(&filter, sizeof(filter));
	filter.mdst.bits = -1;
	filter.msrc.bits = -1;
}

int route_exec(int route_cmd, int route_type, int route_scope,
			   unsigned flags, inet_prefix * src, inet_prefix * to,
			   struct nexthop *nhops, char *dev, u_char table);

int
route_add(ROUTE_CMD_VARS)
{
	return route_exec(RTM_NEWROUTE, type, scope, NLM_F_CREATE | NLM_F_EXCL,
					  src, to, nhops, dev, table);
}

int
route_del(ROUTE_CMD_VARS)
{
	return route_exec(RTM_DELROUTE, type, scope, 0, src, to, nhops, dev,
					  table);
}

/*If it doesn't exist, CREATE IT! de ih oh oh*/
int
route_replace(ROUTE_CMD_VARS)
{
	return route_exec(RTM_NEWROUTE, type, scope,
					  NLM_F_REPLACE | NLM_F_CREATE, src, to, nhops, dev,
					  table);
}

int
route_change(ROUTE_CMD_VARS)
{
	return route_exec(RTM_NEWROUTE, type, scope, NLM_F_REPLACE, src, to,
					  nhops, dev, table);
}

int
route_append(ROUTE_CMD_VARS)
{
	return route_exec(RTM_NEWROUTE, type, scope,
					  NLM_F_CREATE | NLM_F_APPEND, src, to, nhops, dev,
					  table);
}

int
add_nexthops(struct nlmsghdr *n, struct rtmsg *r, struct nexthop *nhop)
{
	char buf[1024];
	struct rtattr *rta = (void *) buf;
	struct rtnexthop *rtnh;
	int i = 0, idx;

	rta->rta_type = RTA_MULTIPATH;
	rta->rta_len = RTA_LENGTH(0);
	rtnh = RTA_DATA(rta);

	if (!nhop[i + 1].dev) {
		/* Just one gateway */
		r->rtm_family = nhop[i].gw.family;
		addattr_l(n, sizeof(struct rt_request), RTA_GATEWAY,
				  &nhop[i].gw.data, nhop[i].gw.len);

		if (nhop[0].dev) {
			if ((idx = ll_name_to_index(nhop[0].dev)) == 0) {
				error(ERROR_MSG "Device \"%s\" doesn't really exist\n",
					  ERROR_POS, nhop[0].dev);
				return -1;
			}
			addattr32(n, sizeof(struct rt_request), RTA_OIF, idx);
		}

		return 0;
	}
#if 0
	/* We have more than one nexthop, equalize them */
	req.rt.rtm_flags |= RTM_F_EQUALIZE;
#endif

	while (nhop[i].dev != 0) {
		setzero(rtnh, sizeof(*rtnh));
		rtnh->rtnh_len = sizeof(*rtnh);
		rta->rta_len += rtnh->rtnh_len;

		if (nhop[i].gw.len) {
			if (nhop[i].gw.family == AF_INET)
				rta_addattr32(rta, 4096, RTA_GATEWAY, nhop[i].gw.data[0]);
			else if (nhop[i].gw.family == AF_INET6)
				rta_addattr_l(rta, 4096, RTA_GATEWAY, nhop[i].gw.data,
							  nhop[i].gw.len);
			rtnh->rtnh_len += sizeof(struct rtattr) + nhop[i].gw.len;
		}

		if (nhop[i].dev)
			if ((rtnh->rtnh_ifindex = ll_name_to_index(nhop[i].dev)) == 0)
				fatal("%s:%d, Cannot find device \"%s\"\n", ERROR_POS,
					  nhop[i].dev);

		if (nhop[i].hops == 0) {
			debug(DBG_NORMAL, "hops=%d is invalid. Using hops=255\n",
				  nhop[i].hops);
			rtnh->rtnh_hops = 255;
		} else
			rtnh->rtnh_hops = nhop[i].hops - 1;

		rtnh = RTNH_NEXT(rtnh);
		i++;
	}

	if (rta->rta_len > RTA_LENGTH(0))
		addattr_l(n, 1024, RTA_MULTIPATH, RTA_DATA(rta), RTA_PAYLOAD(rta));
	return 0;
}

/*
 * route_exec: replaces, adds or deletes a route from the routing table.
 * `to' and nhops->gw must be addresses given in network order
 */
int
route_exec(int route_cmd, int route_type, int route_scope, unsigned flags,
		   inet_prefix * src, inet_prefix * to, struct nexthop *nhops,
		   char *dev, u_char table)
{
	struct rt_request req;
	struct rtnl_handle rth;

	setzero(&req, sizeof(req));

	if (!table)
		table = RT_TABLE_MAIN;

	req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
	req.nh.nlmsg_flags = NLM_F_REQUEST | flags;
	req.nh.nlmsg_type = route_cmd;
	req.rt.rtm_family = AF_UNSPEC;
	req.rt.rtm_table = table;
	req.rt.rtm_protocol = RTPROT_NETSUKUKU;
	req.rt.rtm_scope = RT_SCOPE_NOWHERE;
	req.rt.rtm_type = RTN_UNSPEC;

	/* kernel protocol layer */
	if (table == RT_TABLE_LOCAL)
		req.rt.rtm_protocol = RTPROT_KERNEL;

	if (route_cmd != RTM_DELROUTE) {
		req.rt.rtm_scope = RT_SCOPE_UNIVERSE;
		req.rt.rtm_type = RTN_UNICAST;
	}

	if (route_type)
		req.rt.rtm_type = route_type;

	if (route_scope)
		req.rt.rtm_scope = route_scope;
	else if (req.rt.rtm_type == RTN_LOCAL)
		req.rt.rtm_scope = RT_SCOPE_HOST;


	if (rtnl_open(&rth, 0) < 0)
		return -1;

	if (dev || nhops)
		ll_init_map(&rth);

#ifdef LINUX_2_6_14
	uint32_t mp_alg = NTK_MULTIPATH_ALGO;
	addattr_l(&req.n, sizeof(req), RTA_MP_ALGO, &mp_alg, sizeof(mp_alg));
#endif

	if (dev) {
		int idx;

		if ((idx = ll_name_to_index(dev)) == 0) {
			error("%s:%d, Device \"%s\" doesn't really exist\n", ERROR_POS,
				  dev);
			return -1;
		}
		addattr32(&req.nh, sizeof(req), RTA_OIF, idx);
	}

	if (to) {
		req.rt.rtm_family = to->family;
		req.rt.rtm_dst_len = to->bits;

		if (!to->data[0] && !to->data[1] && !to->data[2] && !to->data[3]) {
			/* Modify the default gw */
			if (route_cmd == RTM_DELROUTE)
				req.rt.rtm_protocol = 0;
		}

		if (to->len)
			addattr_l(&req.nh, sizeof(req), RTA_DST, &to->data, to->len);
	}

	if (src) {
		if (req.rt.rtm_family == AF_UNSPEC)
			req.rt.rtm_family = src->family;
		addattr_l(&req.nh, sizeof(req), RTA_PREFSRC, &src->data, src->len);
	}

	if (nhops)
		add_nexthops(&req.nh, &req.rt, nhops);

	if (req.rt.rtm_family == AF_UNSPEC)
		req.rt.rtm_family = AF_INET;

	/*Finaly stage: <<Hey krnl, r u there?>> */
	if (rtnl_talk(&rth, &req.nh, 0, 0, NULL, NULL, NULL) < 0)
		return -1;

	rtnl_close(&rth);

	return 0;
}

/*
 * route_get_gw: if the route stored in `who' and `n' is matched by the
 * `filter', it stores the gateway address of that route in `arg', which
 * is a pointer to an inet_prefix struct. The address is stored in host order.
 * The dev name of the route is appended at `arg'+sizeof(inet_prefix).
 * Only the non-deleted routes are considered.
 */
int
route_get_gw(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
{
	struct rtmsg *r = NLMSG_DATA(n);
	int len = n->nlmsg_len;
	struct rtattr *tb[RTA_MAX + 1];
	inet_prefix dst;
	inet_prefix via;
	int host_len = -1;


	if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE)
		return 0;
	if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
		return 0;
	len -= NLMSG_LENGTH(sizeof(*r));
	if (len < 0)
		return -1;

	if (r->rtm_family == AF_INET6)
		host_len = 128;
	else if (r->rtm_family == AF_INET)
		host_len = 32;
	else if (r->rtm_family == AF_DECnet)
		host_len = 16;
	else if (r->rtm_family == AF_IPX)
		host_len = 80;

	if (r->rtm_family == AF_INET6) {
		if (filter.tb) {
			if (filter.tb < 0) {
				if (!(r->rtm_flags & RTM_F_CLONED))
					return 0;
			} else {
				if (r->rtm_flags & RTM_F_CLONED)
					return 0;
				if (filter.tb == RT_TABLE_LOCAL) {
					if (r->rtm_type != RTN_LOCAL)
						return 0;
				} else if (filter.tb == RT_TABLE_MAIN) {
					if (r->rtm_type == RTN_LOCAL)
						return 0;
				} else {
					return 0;
				}
			}
		}
	} else {
		if (filter.tb > 0 && filter.tb != r->rtm_table)
			return 0;
	}
	if ((filter.protocol ^ r->rtm_protocol) & filter.protocolmask)
		return 0;
	if ((filter.scope ^ r->rtm_scope) & filter.scopemask)
		return 0;
	if ((filter.type ^ r->rtm_type) & filter.typemask)
		return 0;
	if ((filter.tos ^ r->rtm_tos) & filter.tosmask)
		return 0;
	if (filter.rdst.family &&
		(r->rtm_family != filter.rdst.family
		 || filter.rdst.bits > r->rtm_dst_len))
		return 0;
	if (filter.mdst.family &&
		(r->rtm_family != filter.mdst.family ||
		 (filter.mdst.bits < r->rtm_dst_len)))
		return 0;
	if (filter.rsrc.family &&
		(r->rtm_family != filter.rsrc.family
		 || filter.rsrc.bits > r->rtm_src_len))
		return 0;
	if (filter.msrc.family &&
		(r->rtm_family != filter.msrc.family ||
		 (filter.msrc.bits < r->rtm_src_len)))
		return 0;
	if (filter.rvia.family && r->rtm_family != filter.rvia.family)
		return 0;
	if (filter.rprefsrc.family && r->rtm_family != filter.rprefsrc.family)
		return 0;

	parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);

	setzero(&dst, sizeof(dst));
	dst.family = r->rtm_family;
	if (tb[RTA_DST]) {
		memcpy(&dst.data, RTA_DATA(tb[RTA_DST]), (r->rtm_dst_len + 7) / 8);
	}
	if (filter.rdst.family
		&& inet_addr_match(&dst, &filter.rdst, filter.rdst.bits))
		return 0;
	if (filter.mdst.family &&
		inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))
		return 0;

	if (n->nlmsg_type == RTM_DELROUTE)
		return 0;

	/*
	 * ... and finally if all the tests passed, copy the gateway address
	 */
	if (tb[RTA_GATEWAY]) {
		memcpy(&via.data, RTA_DATA(tb[RTA_GATEWAY]), host_len / 8);
		via.family = r->rtm_family;
		inet_setip(arg, (u_int *) & via.data, via.family);
	} else if (tb[RTA_MULTIPATH]) {
		struct rtnexthop *nh = RTA_DATA(tb[RTA_MULTIPATH]);

		len = RTA_PAYLOAD(tb[RTA_MULTIPATH]);

		for (;;) {
			if (len < sizeof(*nh))
				break;
			if (nh->rtnh_len > len)
				break;
			if (r->rtm_flags & RTM_F_CLONED
				&& r->rtm_type == RTN_MULTICAST)
				goto skip_nexthop;

			if (nh->rtnh_len > sizeof(*nh)) {
				parse_rtattr(tb, RTA_MAX, RTNH_DATA(nh),
							 nh->rtnh_len - sizeof(*nh));
				if (tb[RTA_GATEWAY]) {
					memcpy(&via.data, RTA_DATA(tb[RTA_GATEWAY]),
						   host_len / 8);
					via.family = r->rtm_family;
					inet_setip(arg, (u_int *) & via.data, via.family);

					/* Copy the interface name */
					strncpy((char *) arg + sizeof(inet_prefix),
							ll_index_to_name(nh->rtnh_ifindex), IFNAMSIZ);
					break;
				}
			}
		  skip_nexthop:
			len -= NLMSG_ALIGN(nh->rtnh_len);
			nh = RTNH_NEXT(nh);
		}
	}


	/* Copy the interface name */
	if (tb[RTA_OIF] && filter.oifmask != -1)
		strncpy((char *) arg + sizeof(inet_prefix),
				ll_index_to_name(*(int *) RTA_DATA(tb[RTA_OIF])),
				IFNAMSIZ);

	return 0;
}

/*
 * route_get_exact_prefix: it dumps the routing table and search for a route
 * which has the prefix equal to `prefix', if it is found its destination
 * address is stored in `dst' and its interface name in `dev_name' (which must
 * be IFNAMSIZ big).
 */
int
route_get_exact_prefix_dst(inet_prefix prefix, inet_prefix * dst,
						   char *dev_name)
{
	int do_ipv6 = AF_UNSPEC;
	struct rtnl_handle rth;
	char dst_data[sizeof(inet_prefix) + IFNAMSIZ];

	route_reset_filter();
	filter.tb = RT_TABLE_MAIN;

	filter.mdst = prefix;
	filter.rdst = filter.mdst;

	if (do_ipv6 == AF_UNSPEC && filter.tb)
		do_ipv6 = AF_INET;

	if (rtnl_open(&rth, 0) < 0)
		return -1;

	ll_init_map(&rth);

	if (rtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE) < 0) {
		error(ERROR_MSG "Cannot send dump request" ERROR_POS);
		return -1;
	}

	setzero(dst_data, sizeof(dst_data));
	if (rtnl_dump_filter(&rth, route_get_gw, dst_data, NULL, NULL) < 0) {
		debug(DBG_NORMAL, ERROR_MSG "Dump terminated" ERROR_POS);
		return -1;
	}
	inet_copy(dst, (inet_prefix *) dst_data);
	memcpy(dev_name, dst_data + sizeof(inet_prefix), IFNAMSIZ);

	rtnl_close(&rth);

	return 0;
}

int
route_flush_cache(int family)
{
	int len, err;
	int flush_fd;
	char ROUTE_FLUSH_SYSCTL[] = "/proc/sys/net/ipvX/route/flush";
	char *buf = "-1";

	len = strlen(buf);
	if (family == AF_INET)
		ROUTE_FLUSH_SYSCTL[17] = '4';
	else if (family == AF_INET6)
		ROUTE_FLUSH_SYSCTL[17] = '6';
	else
		return -1;

	flush_fd = open(ROUTE_FLUSH_SYSCTL, O_WRONLY);
	if (flush_fd < 0) {
		debug(DBG_NORMAL, "Cannot open \"%s\"\n", ROUTE_FLUSH_SYSCTL);
		return -1;
	}

	if ((err = write(flush_fd, (void *) buf, len)) == 0) {
		debug(DBG_NORMAL, "Warning: Route Cache not flushed\n");
		return -1;
	} else if (err == -1) {
		debug(DBG_NORMAL, "Cannot flush routing cache: %s\n",
			  strerror(errno));
		return -1;
	}
	close(flush_fd);

	return 0;
}

int
route_ip_forward(int family, int enable)
{
	int len, err;
	int flush_fd;
	char *ROUTE_FORWARD_SYSCTL = "/proc/sys/net/ipv4/ip_forward";
	char *ROUTE_FORWARD_SYSCTL_6 =
		"/proc/sys/net/ipv6/conf/all/forwarding";
	char *sysctl_path, buf[2];

	buf[0] = '1';
	buf[1] = 0;

	len = strlen(buf);
	if (family == AF_INET)
		sysctl_path = ROUTE_FORWARD_SYSCTL;
	else if (family == AF_INET6)
		sysctl_path = ROUTE_FORWARD_SYSCTL_6;
	else
		return -1;

	if (!enable)
		buf[0] = '0';

	flush_fd = open(sysctl_path, O_WRONLY);
	if (flush_fd < 0) {
		debug(DBG_NORMAL, "Cannot open \"%s\"\n", sysctl_path);
		return -1;
	}

	if ((err = write(flush_fd, (void *) buf, len)) == 0) {
		debug(DBG_NORMAL, "Warning: ip_forward setting changed\n");
		return -1;
	} else if (err == -1) {
		debug(DBG_NORMAL, "Cannot change the ip_forward setting: %s\n",
			  strerror(errno));
		return -1;
	}
	close(flush_fd);

	return 0;
}

/*
 * route_rp_filter
 *
 * Modifies the /proc/sys/net/ipv4/conf/INTERFACE/rp_filter config file.
 */
int
route_rp_filter(int family, char *dev, int enable)
{
	int len, err, ret = 0;
	int flush_fd;

	/* The path is /proc/sys/net/ipv4/conf/INTERFACE/rp_filter */
	const char *RP_FILTER_SYSCTL_1 = "/proc/sys/net/ipv4/conf/";
	const char *RP_FILTER_SYSCTL_1_IPV6 = "/proc/sys/net/ipv6/conf/";
	const char *RP_FILTER_SYSCTL_2 = "/rp_filter";
	char *final_path = 0, buf[2];

	buf[0] = '1';
	buf[1] = 0;
#define RP_FILTER_PATH_SZ (strlen(RP_FILTER_SYSCTL_1)+		   \
			   strlen(RP_FILTER_SYSCTL_2)+IF_NAMESIZE+1)
	final_path = xzalloc(RP_FILTER_PATH_SZ);

	len = strlen(buf);
	if (family == AF_INET) {
		strcpy(final_path, RP_FILTER_SYSCTL_1);
	} else if (family == AF_INET6) {
		strcpy(final_path, RP_FILTER_SYSCTL_1_IPV6);
	} else
		ERROR_FINISH(ret, -1, finish);

	strcat(final_path, dev);
	strcat(final_path, RP_FILTER_SYSCTL_2);

	if (!enable)
		buf[0] = '0';

	flush_fd = open(final_path, O_WRONLY);
	if (flush_fd < 0) {
		debug(DBG_NORMAL, "Cannot open \"%s\"\n", final_path);
		ERROR_FINISH(ret, -1, finish);
	}

	if ((err = write(flush_fd, (void *) buf, len)) == 0) {
		debug(DBG_NORMAL, "Warning: rp_filter setting changed\n");
		ERROR_FINISH(ret, -1, finish);
	} else if (err == -1) {
		debug(DBG_NORMAL, "Cannot change the rp_filter setting: %s\n",
			  strerror(errno));
		ERROR_FINISH(ret, -1, finish);
	}
	close(flush_fd);

  finish:
	if (final_path)
		xfree(final_path);
	return ret;
}

/*
 * route_rp_filter_all_dev: do route_rp_filter() for all the interfaces
 * present in the `ifs' array.
 */
int
route_rp_filter_all_dev(int family, interface * ifs, int ifs_n, int enable)
{
	int i, ret = 0;

	for (i = 0; i < ifs_n; i++)
		ret += route_rp_filter(family, ifs[i].dev_name, enable);

	return ret;
}

/*Life is strange*/