/***
 *
 *  ipv4/route.c - real-time routing
 *
 *  Copyright (C) 2004, 2005 Jan Kiszka <jan.kiszka@web.de>
 *
 *  Rewritten version of the original route by David Schleef and Ulrich Marx
 *
 *  This program 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 program 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.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <linux/moduleparam.h>
#include <net/ip.h>

#include <rtnet_internal.h>
#include <rtnet_port.h>
#include <rtnet_chrdev.h>
#include <ipv4/af_inet.h>
#include <ipv4/route.h>

/* FIXME: should also become some tunable parameter */
#define ROUTER_FORWARD_PRIO                                                    \
	RTSKB_PRIO_VALUE(QUEUE_MAX_PRIO +                                      \
				 (QUEUE_MIN_PRIO - QUEUE_MAX_PRIO + 1) / 2,    \
			 RTSKB_DEF_RT_CHANNEL)

/* First-level routing: explicite host routes */
struct host_route {
	struct host_route *next;
	struct dest_route dest_host;
};

/* Second-level routing: routes to other networks */
struct net_route {
	struct net_route *next;
	u32 dest_net_ip;
	u32 dest_net_mask;
	u32 gw_ip;
};

#if (CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES &                              \
     (CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES - 1))
#error CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES must be power of 2
#endif
#if CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES < 256
#define HOST_HASH_TBL_SIZE 64
#else
#define HOST_HASH_TBL_SIZE                                                     \
	((CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES / 256) * 64)
#endif
#define HOST_HASH_KEY_MASK (HOST_HASH_TBL_SIZE - 1)

static struct host_route host_routes[CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES];
static struct host_route *free_host_route;
static int allocated_host_routes;
static struct host_route *host_hash_tbl[HOST_HASH_TBL_SIZE];
static DEFINE_RTDM_LOCK(host_table_lock);

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
#if (CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES &                               \
     (CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES - 1))
#error CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES must be power of 2
#endif
#if CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES < 256
#define NET_HASH_TBL_SIZE 64
#else
#define NET_HASH_TBL_SIZE                                                      \
	((CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES / 256) * 64)
#endif
#define NET_HASH_KEY_MASK (NET_HASH_TBL_SIZE - 1)
#define NET_HASH_KEY_SHIFT 8

static struct net_route net_routes[CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES];
static struct net_route *free_net_route;
static int allocated_net_routes;
static struct net_route *net_hash_tbl[NET_HASH_TBL_SIZE + 1];
static unsigned int net_hash_key_shift = NET_HASH_KEY_SHIFT;
static DEFINE_RTDM_LOCK(net_table_lock);

module_param(net_hash_key_shift, uint, 0444);
MODULE_PARM_DESC(net_hash_key_shift, "destination right shift for "
				     "network hash key (default: 8)");
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

/***
 *  proc filesystem section
 */
#ifdef CONFIG_XENO_OPT_VFILE
static int rtnet_ipv4_route_show(struct xnvfile_regular_iterator *it, void *d)
{
#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
	u32 mask;
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

	xnvfile_printf(it,
		       "Host routes allocated/total:\t%d/%d\n"
		       "Host hash table size:\t\t%d\n",
		       allocated_host_routes,
		       CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES,
		       HOST_HASH_TBL_SIZE);

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
	mask = NET_HASH_KEY_MASK << net_hash_key_shift;
	xnvfile_printf(it,
		       "Network routes allocated/total:\t%d/%d\n"
		       "Network hash table size:\t%d\n"
		       "Network hash key shift/mask:\t%d/%08X\n",
		       allocated_net_routes,
		       CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES,
		       NET_HASH_TBL_SIZE, net_hash_key_shift, mask);
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_ROUTER
	xnvfile_printf(it, "IP Router:\t\t\tyes\n");
#else
	xnvfile_printf(it, "IP Router:\t\t\tno\n");
#endif

	return 0;
}

static int rtnet_ipv4_module_lock(struct xnvfile *vfile)
{
	bool res = try_module_get(THIS_MODULE);
	if (!res)
		return -EIDRM;

	return 0;
}

static void rtnet_ipv4_module_unlock(struct xnvfile *vfile)
{
	module_put(THIS_MODULE);
}

static struct xnvfile_lock_ops rtnet_ipv4_module_lock_ops = {
	.get = rtnet_ipv4_module_lock,
	.put = rtnet_ipv4_module_unlock,
};

static struct xnvfile_regular_ops rtnet_ipv4_route_vfile_ops = {
	.show = rtnet_ipv4_route_show,
};

static struct xnvfile_regular rtnet_ipv4_route_vfile = {
    .entry = {
	.lockops = &rtnet_ipv4_module_lock_ops,
    },
    .ops = &rtnet_ipv4_route_vfile_ops,
};

static rtdm_lockctx_t rtnet_ipv4_host_route_lock_ctx;

static int rtnet_ipv4_host_route_lock(struct xnvfile *vfile)
{
	rtdm_lock_get_irqsave(&host_table_lock, rtnet_ipv4_host_route_lock_ctx);
	return 0;
}

static void rtnet_ipv4_host_route_unlock(struct xnvfile *vfile)
{
	rtdm_lock_put_irqrestore(&host_table_lock,
				 rtnet_ipv4_host_route_lock_ctx);
}

static struct xnvfile_lock_ops rtnet_ipv4_host_route_lock_ops = {
	.get = rtnet_ipv4_host_route_lock,
	.put = rtnet_ipv4_host_route_unlock,
};

struct rtnet_ipv4_host_route_priv {
	unsigned key;
	struct host_route *entry_ptr;
};

struct rtnet_ipv4_host_route_data {
	int key;
	char name[IFNAMSIZ];
	struct dest_route dest_host;
};

struct xnvfile_rev_tag host_route_tag;

static void *rtnet_ipv4_host_route_begin(struct xnvfile_snapshot_iterator *it)
{
	struct rtnet_ipv4_host_route_priv *priv = xnvfile_iterator_priv(it);
	struct rtnet_ipv4_host_route_data *data;
	unsigned routes;
	int err;

	routes = allocated_host_routes;
	if (!routes)
		return VFILE_SEQ_EMPTY;

	data = kmalloc(sizeof(*data) * routes, GFP_KERNEL);
	if (data == NULL)
		return NULL;

	err = rtnet_ipv4_module_lock(NULL);
	if (err < 0) {
		kfree(data);
		return VFILE_SEQ_EMPTY;
	}

	priv->key = -1;
	priv->entry_ptr = NULL;
	return data;
}

static void rtnet_ipv4_host_route_end(struct xnvfile_snapshot_iterator *it,
				      void *buf)
{
	rtnet_ipv4_module_unlock(NULL);
	kfree(buf);
}

static int rtnet_ipv4_host_route_next(struct xnvfile_snapshot_iterator *it,
				      void *data)
{
	struct rtnet_ipv4_host_route_priv *priv = xnvfile_iterator_priv(it);
	struct rtnet_ipv4_host_route_data *p = data;
	struct rtnet_device *rtdev;

	if (priv->entry_ptr == NULL) {
		if (++priv->key >= HOST_HASH_TBL_SIZE)
			return 0;

		priv->entry_ptr = host_hash_tbl[priv->key];
		if (priv->entry_ptr == NULL)
			return VFILE_SEQ_SKIP;
	}

	rtdev = priv->entry_ptr->dest_host.rtdev;

	if (!rtdev_reference(rtdev))
		return -EIDRM;

	memcpy(&p->name, rtdev->name, sizeof(p->name));

	rtdev_dereference(rtdev);

	p->key = priv->key;

	memcpy(&p->dest_host, &priv->entry_ptr->dest_host,
	       sizeof(p->dest_host));

	priv->entry_ptr = priv->entry_ptr->next;

	return 1;
}

static int rtnet_ipv4_host_route_show(struct xnvfile_snapshot_iterator *it,
				      void *data)
{
	struct rtnet_ipv4_host_route_data *p = data;

	if (p == NULL) {
		xnvfile_printf(it, "Hash\tDestination\tHW Address\t\tDevice\n");
		return 0;
	}

	xnvfile_printf(it,
		       "%02X\t%u.%u.%u.%-3u\t"
		       "%02X:%02X:%02X:%02X:%02X:%02X\t%s\n",
		       p->key, NIPQUAD(p->dest_host.ip),
		       p->dest_host.dev_addr[0], p->dest_host.dev_addr[1],
		       p->dest_host.dev_addr[2], p->dest_host.dev_addr[3],
		       p->dest_host.dev_addr[4], p->dest_host.dev_addr[5],
		       p->name);
	return 0;
}

static struct xnvfile_snapshot_ops rtnet_ipv4_host_route_vfile_ops = {
	.begin = rtnet_ipv4_host_route_begin,
	.end = rtnet_ipv4_host_route_end,
	.next = rtnet_ipv4_host_route_next,
	.show = rtnet_ipv4_host_route_show,
};

static struct xnvfile_snapshot rtnet_ipv4_host_route_vfile = {
    .entry = {
	.lockops = &rtnet_ipv4_host_route_lock_ops,
    },
    .privsz = sizeof(struct rtnet_ipv4_host_route_priv),
    .datasz = sizeof(struct rtnet_ipv4_host_route_data),
    .tag = &host_route_tag,
    .ops = &rtnet_ipv4_host_route_vfile_ops,
};

static struct xnvfile_link rtnet_ipv4_arp_vfile;

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
static rtdm_lockctx_t rtnet_ipv4_net_route_lock_ctx;

static int rtnet_ipv4_net_route_lock(struct xnvfile *vfile)
{
	rtdm_lock_get_irqsave(&net_table_lock, rtnet_ipv4_net_route_lock_ctx);
	return 0;
}

static void rtnet_ipv4_net_route_unlock(struct xnvfile *vfile)
{
	rtdm_lock_put_irqrestore(&net_table_lock,
				 rtnet_ipv4_net_route_lock_ctx);
}

static struct xnvfile_lock_ops rtnet_ipv4_net_route_lock_ops = {
	.get = rtnet_ipv4_net_route_lock,
	.put = rtnet_ipv4_net_route_unlock,
};

struct rtnet_ipv4_net_route_priv {
	unsigned key;
	struct net_route *entry_ptr;
};

struct rtnet_ipv4_net_route_data {
	int key;
	u32 dest_net_ip;
	u32 dest_net_mask;
	u32 gw_ip;
};

struct xnvfile_rev_tag net_route_tag;

static void *rtnet_ipv4_net_route_begin(struct xnvfile_snapshot_iterator *it)
{
	struct rtnet_ipv4_net_route_priv *priv = xnvfile_iterator_priv(it);
	struct rtnet_ipv4_net_route_data *data;
	unsigned routes;
	int err;

	routes = allocated_net_routes;
	if (!routes)
		return VFILE_SEQ_EMPTY;

	data = kmalloc(sizeof(*data) * routes, GFP_KERNEL);
	if (data == NULL)
		return NULL;

	err = rtnet_ipv4_module_lock(NULL);
	if (err < 0) {
		kfree(data);
		return VFILE_SEQ_EMPTY;
	}

	priv->key = -1;
	priv->entry_ptr = NULL;
	return data;
}

static void rtnet_ipv4_net_route_end(struct xnvfile_snapshot_iterator *it,
				     void *buf)
{
	rtnet_ipv4_module_unlock(NULL);
	kfree(buf);
}

static int rtnet_ipv4_net_route_next(struct xnvfile_snapshot_iterator *it,
				     void *data)
{
	struct rtnet_ipv4_net_route_priv *priv = xnvfile_iterator_priv(it);
	struct rtnet_ipv4_net_route_data *p = data;

	if (priv->entry_ptr == NULL) {
		if (++priv->key >= NET_HASH_TBL_SIZE + 1)
			return 0;

		priv->entry_ptr = net_hash_tbl[priv->key];
		if (priv->entry_ptr == NULL)
			return VFILE_SEQ_SKIP;
	}

	p->key = priv->key;
	p->dest_net_ip = priv->entry_ptr->dest_net_ip;
	p->dest_net_mask = priv->entry_ptr->dest_net_mask;
	p->gw_ip = priv->entry_ptr->gw_ip;

	priv->entry_ptr = priv->entry_ptr->next;

	return 1;
}

static int rtnet_ipv4_net_route_show(struct xnvfile_snapshot_iterator *it,
				     void *data)
{
	struct rtnet_ipv4_net_route_data *p = data;

	if (p == NULL) {
		xnvfile_printf(it, "Hash\tDestination\tMask\t\t\tGateway\n");
		return 0;
	}

	if (p->key < NET_HASH_TBL_SIZE)
		xnvfile_printf(it,
			       "%02X\t%u.%u.%u.%-3u\t%u.%u.%u.%-3u"
			       "\t\t%u.%u.%u.%-3u\n",
			       p->key, NIPQUAD(p->dest_net_ip),
			       NIPQUAD(p->dest_net_mask), NIPQUAD(p->gw_ip));
	else
		xnvfile_printf(it,
			       "*\t%u.%u.%u.%-3u\t%u.%u.%u.%-3u\t\t"
			       "%u.%u.%u.%-3u\n",
			       NIPQUAD(p->dest_net_ip),
			       NIPQUAD(p->dest_net_mask), NIPQUAD(p->gw_ip));

	return 0;
}

static struct xnvfile_snapshot_ops rtnet_ipv4_net_route_vfile_ops = {
	.begin = rtnet_ipv4_net_route_begin,
	.end = rtnet_ipv4_net_route_end,
	.next = rtnet_ipv4_net_route_next,
	.show = rtnet_ipv4_net_route_show,
};

static struct xnvfile_snapshot rtnet_ipv4_net_route_vfile = {
    .entry = {
	.lockops = &rtnet_ipv4_net_route_lock_ops,
    },
    .privsz = sizeof(struct rtnet_ipv4_net_route_priv),
    .datasz = sizeof(struct rtnet_ipv4_net_route_data),
    .tag = &net_route_tag,
    .ops = &rtnet_ipv4_net_route_vfile_ops,
};
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

static int __init rt_route_proc_register(void)
{
	int err;

	err = xnvfile_init_regular("route", &rtnet_ipv4_route_vfile,
				   &ipv4_proc_root);
	if (err < 0)
		goto err1;

	err = xnvfile_init_snapshot("host_route", &rtnet_ipv4_host_route_vfile,
				    &ipv4_proc_root);
	if (err < 0)
		goto err2;

	/* create "arp" as an alias for "host_route" */
	err = xnvfile_init_link("arp", "host_route", &rtnet_ipv4_arp_vfile,
				&ipv4_proc_root);
	if (err < 0)
		goto err3;

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
	err = xnvfile_init_snapshot("net_route", &rtnet_ipv4_net_route_vfile,
				    &ipv4_proc_root);
	if (err < 0)
		goto err4;
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

	return 0;

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
err4:
	xnvfile_destroy_link(&rtnet_ipv4_arp_vfile);
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

err3:
	xnvfile_destroy_snapshot(&rtnet_ipv4_host_route_vfile);

err2:
	xnvfile_destroy_regular(&rtnet_ipv4_route_vfile);

err1:
	printk("RTnet: unable to initialize /proc entries (route)\n");
	return err;
}

static void rt_route_proc_unregister(void)
{
#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
	xnvfile_destroy_snapshot(&rtnet_ipv4_net_route_vfile);
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */
	xnvfile_destroy_link(&rtnet_ipv4_arp_vfile);
	xnvfile_destroy_snapshot(&rtnet_ipv4_host_route_vfile);
	xnvfile_destroy_regular(&rtnet_ipv4_route_vfile);
}
#endif /* CONFIG_XENO_OPT_VFILE */

/***
 *  rt_alloc_host_route - allocates new host route
 */
static inline struct host_route *rt_alloc_host_route(void)
{
	rtdm_lockctx_t context;
	struct host_route *rt;

	rtdm_lock_get_irqsave(&host_table_lock, context);

	if ((rt = free_host_route) != NULL) {
		free_host_route = rt->next;
		allocated_host_routes++;
	}

	rtdm_lock_put_irqrestore(&host_table_lock, context);

	return rt;
}

/***
 *  rt_free_host_route - releases host route
 *
 *  Note: must be called with host_table_lock held
 */
static inline void rt_free_host_route(struct host_route *rt)
{
	rt->next = free_host_route;
	free_host_route = rt;
	allocated_host_routes--;
}

/***
 *  rt_ip_route_add_host: add or update host route
 */
int rt_ip_route_add_host(u32 addr, unsigned char *dev_addr,
			 struct rtnet_device *rtdev)
{
	rtdm_lockctx_t context;
	struct host_route *new_route;
	struct host_route *rt;
	unsigned int key;
	int ret = 0;

	rtdm_lock_get_irqsave(&rtdev->rtdev_lock, context);

	if ((!test_bit(PRIV_FLAG_UP, &rtdev->priv_flags) ||
	     test_and_set_bit(PRIV_FLAG_ADDING_ROUTE, &rtdev->priv_flags))) {
		rtdm_lock_put_irqrestore(&rtdev->rtdev_lock, context);
		return -EBUSY;
	}

	rtdm_lock_put_irqrestore(&rtdev->rtdev_lock, context);

	if ((new_route = rt_alloc_host_route()) != NULL) {
		new_route->dest_host.ip = addr;
		new_route->dest_host.rtdev = rtdev;
		memcpy(new_route->dest_host.dev_addr, dev_addr,
		       rtdev->addr_len);
	}

	key = ntohl(addr) & HOST_HASH_KEY_MASK;

	rtdm_lock_get_irqsave(&host_table_lock, context);

	xnvfile_touch_tag(&host_route_tag);

	rt = host_hash_tbl[key];
	while (rt != NULL) {
		if ((rt->dest_host.ip == addr) &&
		    (rt->dest_host.rtdev->local_ip == rtdev->local_ip)) {
			rt->dest_host.rtdev = rtdev;
			memcpy(rt->dest_host.dev_addr, dev_addr,
			       rtdev->addr_len);

			if (new_route)
				rt_free_host_route(new_route);

			rtdm_lock_put_irqrestore(&host_table_lock, context);

			goto out;
		}

		rt = rt->next;
	}

	if (new_route) {
		new_route->next = host_hash_tbl[key];
		host_hash_tbl[key] = new_route;

		rtdm_lock_put_irqrestore(&host_table_lock, context);
	} else {
		rtdm_lock_put_irqrestore(&host_table_lock, context);

		/*ERRMSG*/ rtdm_printk(
			"RTnet: no more host routes available\n");
		ret = -ENOBUFS;
	}

out:
	clear_bit(PRIV_FLAG_ADDING_ROUTE, &rtdev->priv_flags);

	return ret;
}

/***
 *  rt_ip_route_del_host - deletes specified host route
 */
int rt_ip_route_del_host(u32 addr, struct rtnet_device *rtdev)
{
	rtdm_lockctx_t context;
	struct host_route *rt;
	struct host_route **last_ptr;
	unsigned int key;

	key = ntohl(addr) & HOST_HASH_KEY_MASK;
	last_ptr = &host_hash_tbl[key];

	rtdm_lock_get_irqsave(&host_table_lock, context);

	rt = host_hash_tbl[key];
	while (rt != NULL) {
		if ((rt->dest_host.ip == addr) &&
		    (!rtdev ||
		     (rt->dest_host.rtdev->local_ip == rtdev->local_ip))) {
			*last_ptr = rt->next;

			rt_free_host_route(rt);

			xnvfile_touch_tag(&host_route_tag);

			rtdm_lock_put_irqrestore(&host_table_lock, context);

			return 0;
		}

		last_ptr = &rt->next;
		rt = rt->next;
	}

	rtdm_lock_put_irqrestore(&host_table_lock, context);

	return -ENOENT;
}

/***
 *  rt_ip_route_del_all - deletes all routes associated with a specified device
 */
void rt_ip_route_del_all(struct rtnet_device *rtdev)
{
	rtdm_lockctx_t context;
	struct host_route *host_rt;
	struct host_route **last_host_ptr;
	unsigned int key;
	u32 ip;

	for (key = 0; key < HOST_HASH_TBL_SIZE; key++) {
	host_start_over:
		last_host_ptr = &host_hash_tbl[key];

		rtdm_lock_get_irqsave(&host_table_lock, context);

		host_rt = host_hash_tbl[key];
		while (host_rt != NULL) {
			if (host_rt->dest_host.rtdev == rtdev) {
				*last_host_ptr = host_rt->next;

				rt_free_host_route(host_rt);

				rtdm_lock_put_irqrestore(&host_table_lock,
							 context);

				goto host_start_over;
			}

			last_host_ptr = &host_rt->next;
			host_rt = host_rt->next;
		}

		rtdm_lock_put_irqrestore(&host_table_lock, context);
	}

	if ((ip = rtdev->local_ip) != 0)
		rt_ip_route_del_host(ip, rtdev);
}

/***
 *  rt_ip_route_get_host - check if specified host route is resolved
 */
int rt_ip_route_get_host(u32 addr, char *if_name, unsigned char *dev_addr,
			 struct rtnet_device *rtdev)
{
	rtdm_lockctx_t context;
	struct host_route *rt;
	unsigned int key;

	key = ntohl(addr) & HOST_HASH_KEY_MASK;

	rtdm_lock_get_irqsave(&host_table_lock, context);

	rt = host_hash_tbl[key];
	while (rt != NULL) {
		if ((rt->dest_host.ip == addr) &&
		    (!rtdev ||
		     rt->dest_host.rtdev->local_ip == rtdev->local_ip)) {
			memcpy(dev_addr, rt->dest_host.dev_addr,
			       rt->dest_host.rtdev->addr_len);
			strncpy(if_name, rt->dest_host.rtdev->name, IFNAMSIZ);

			rtdm_lock_put_irqrestore(&host_table_lock, context);
			return 0;
		}

		rt = rt->next;
	}

	rtdm_lock_put_irqrestore(&host_table_lock, context);

	return -ENOENT;
}

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
/***
 *  rt_alloc_net_route - allocates new network route
 */
static inline struct net_route *rt_alloc_net_route(void)
{
	rtdm_lockctx_t context;
	struct net_route *rt;

	rtdm_lock_get_irqsave(&net_table_lock, context);

	if ((rt = free_net_route) != NULL) {
		free_net_route = rt->next;
		allocated_net_routes++;
	}

	rtdm_lock_put_irqrestore(&net_table_lock, context);

	return rt;
}

/***
 *  rt_free_net_route - releases network route
 *
 *  Note: must be called with net_table_lock held
 */
static inline void rt_free_net_route(struct net_route *rt)
{
	rt->next = free_net_route;
	free_net_route = rt;
	allocated_host_routes--;
}

/***
 *  rt_ip_route_add_net: add or update network route
 */
int rt_ip_route_add_net(u32 addr, u32 mask, u32 gw_addr)
{
	rtdm_lockctx_t context;
	struct net_route *new_route;
	struct net_route *rt;
	struct net_route **last_ptr;
	unsigned int key;
	u32 shifted_mask;

	addr &= mask;

	if ((new_route = rt_alloc_net_route()) != NULL) {
		new_route->dest_net_ip = addr;
		new_route->dest_net_mask = mask;
		new_route->gw_ip = gw_addr;
	}

	shifted_mask = NET_HASH_KEY_MASK << net_hash_key_shift;
	if ((mask & shifted_mask) == shifted_mask)
		key = (ntohl(addr) >> net_hash_key_shift) & NET_HASH_KEY_MASK;
	else
		key = NET_HASH_TBL_SIZE;
	last_ptr = &net_hash_tbl[key];

	rtdm_lock_get_irqsave(&net_table_lock, context);

	xnvfile_touch_tag(&net_route_tag);

	rt = net_hash_tbl[key];
	while (rt != NULL) {
		if ((rt->dest_net_ip == addr) && (rt->dest_net_mask == mask)) {
			rt->gw_ip = gw_addr;

			if (new_route)
				rt_free_net_route(new_route);

			rtdm_lock_put_irqrestore(&net_table_lock, context);

			return 0;
		}

		last_ptr = &rt->next;
		rt = rt->next;
	}

	if (new_route) {
		new_route->next = *last_ptr;
		*last_ptr = new_route;

		rtdm_lock_put_irqrestore(&net_table_lock, context);

		return 0;
	} else {
		rtdm_lock_put_irqrestore(&net_table_lock, context);

		/*ERRMSG*/ rtdm_printk(
			"RTnet: no more network routes available\n");
		return -ENOBUFS;
	}
}

/***
 *  rt_ip_route_del_net - deletes specified network route
 */
int rt_ip_route_del_net(u32 addr, u32 mask)
{
	rtdm_lockctx_t context;
	struct net_route *rt;
	struct net_route **last_ptr;
	unsigned int key;
	u32 shifted_mask;

	addr &= mask;

	shifted_mask = NET_HASH_KEY_MASK << net_hash_key_shift;
	if ((mask & shifted_mask) == shifted_mask)
		key = (ntohl(addr) >> net_hash_key_shift) & NET_HASH_KEY_MASK;
	else
		key = NET_HASH_TBL_SIZE;
	last_ptr = &net_hash_tbl[key];

	rtdm_lock_get_irqsave(&net_table_lock, context);

	rt = net_hash_tbl[key];
	while (rt != NULL) {
		if ((rt->dest_net_ip == addr) && (rt->dest_net_mask == mask)) {
			*last_ptr = rt->next;

			rt_free_net_route(rt);

			xnvfile_touch_tag(&net_route_tag);

			rtdm_lock_put_irqrestore(&net_table_lock, context);

			return 0;
		}

		last_ptr = &rt->next;
		rt = rt->next;
	}

	rtdm_lock_put_irqrestore(&net_table_lock, context);

	return -ENOENT;
}
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

/***
 *  rt_ip_route_output - looks up output route
 *
 *  Note: increments refcount on returned rtdev in rt_buf
 */
int rt_ip_route_output(struct dest_route *rt_buf, u32 daddr, u32 saddr)
{
	rtdm_lockctx_t context;
	struct host_route *host_rt;
	unsigned int key;

#ifndef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
#define DADDR daddr
#else
#define DADDR real_daddr

	struct net_route *net_rt;
	int lookup_gw = 1;
	u32 real_daddr = daddr;

restart:
#endif /* !CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

	key = ntohl(daddr) & HOST_HASH_KEY_MASK;

	rtdm_lock_get_irqsave(&host_table_lock, context);

	host_rt = host_hash_tbl[key];
	if (likely(saddr == INADDR_ANY))
		while (host_rt != NULL) {
			if (host_rt->dest_host.ip == daddr) {
			host_route_found:
				if (!rtdev_reference(
					    host_rt->dest_host.rtdev)) {
					rtdm_lock_put_irqrestore(
						&host_table_lock, context);
					goto next;
				}

				memcpy(rt_buf->dev_addr,
				       &host_rt->dest_host.dev_addr,
				       sizeof(rt_buf->dev_addr));
				rt_buf->rtdev = host_rt->dest_host.rtdev;

				rtdm_lock_put_irqrestore(&host_table_lock,
							 context);

				rt_buf->ip = DADDR;

				return 0;
			}
		next:
			host_rt = host_rt->next;
		}
	else
		while (host_rt != NULL) {
			if ((host_rt->dest_host.ip == daddr) &&
			    (host_rt->dest_host.rtdev->local_ip == saddr))
				goto host_route_found;
			host_rt = host_rt->next;
		}

	rtdm_lock_put_irqrestore(&host_table_lock, context);

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
	if (lookup_gw) {
		lookup_gw = 0;
		key = (ntohl(daddr) >> net_hash_key_shift) & NET_HASH_KEY_MASK;

		rtdm_lock_get_irqsave(&net_table_lock, context);

		net_rt = net_hash_tbl[key];
		while (net_rt != NULL) {
			if (net_rt->dest_net_ip ==
			    (daddr & net_rt->dest_net_mask)) {
				daddr = net_rt->gw_ip;

				rtdm_lock_put_irqrestore(&net_table_lock,
							 context);

				/* start over, now using the gateway ip as destination */
				goto restart;
			}

			net_rt = net_rt->next;
		}

		rtdm_lock_put_irqrestore(&net_table_lock, context);

		/* last try: no hash key */
		rtdm_lock_get_irqsave(&net_table_lock, context);

		net_rt = net_hash_tbl[NET_HASH_TBL_SIZE];
		while (net_rt != NULL) {
			if (net_rt->dest_net_ip ==
			    (daddr & net_rt->dest_net_mask)) {
				daddr = net_rt->gw_ip;

				rtdm_lock_put_irqrestore(&net_table_lock,
							 context);

				/* start over, now using the gateway ip as destination */
				goto restart;
			}

			net_rt = net_rt->next;
		}

		rtdm_lock_put_irqrestore(&net_table_lock, context);
	}
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

	/*ERRMSG*/ rtdm_printk("RTnet: host %u.%u.%u.%u unreachable\n",
			       NIPQUAD(daddr));
	return -EHOSTUNREACH;
}

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_ROUTER
int rt_ip_route_forward(struct rtskb *rtskb, u32 daddr)
{
	struct rtnet_device *rtdev = rtskb->rtdev;
	struct dest_route dest;

	if (likely((daddr == rtdev->local_ip) ||
		   (daddr == rtdev->broadcast_ip) ||
		   (rtdev->flags & IFF_LOOPBACK)))
		return 0;

	if (rtskb_acquire(rtskb, &global_pool) != 0) {
		/*ERRMSG*/ rtdm_printk(
			"RTnet: router overloaded, dropping packet\n");
		goto error;
	}

	if (rt_ip_route_output(&dest, daddr, INADDR_ANY) < 0) {
		/*ERRMSG*/ rtdm_printk(
			"RTnet: unable to forward packet from %u.%u.%u.%u\n",
			NIPQUAD(rtskb->nh.iph->saddr));
		goto error;
	}

	rtskb->rtdev = dest.rtdev;
	rtskb->priority = ROUTER_FORWARD_PRIO;

	if ((dest.rtdev->hard_header) &&
	    (dest.rtdev->hard_header(rtskb, dest.rtdev, ETH_P_IP, dest.dev_addr,
				     dest.rtdev->dev_addr, rtskb->len) < 0))
		goto error;

	rtdev_xmit(rtskb);

	return 1;

error:
	kfree_rtskb(rtskb);
	return 1;
}
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_ROUTER */

/***
 *  rt_ip_routing_init: initialize
 */
int __init rt_ip_routing_init(void)
{
	int i;

	for (i = 0; i < CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES - 2; i++)
		host_routes[i].next = &host_routes[i + 1];
	free_host_route = &host_routes[0];

#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING
	for (i = 0; i < CONFIG_XENO_DRIVERS_NET_RTIPV4_NET_ROUTES - 2; i++)
		net_routes[i].next = &net_routes[i + 1];
	free_net_route = &net_routes[0];
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */

#ifdef CONFIG_XENO_OPT_VFILE
	return rt_route_proc_register();
#else /* !CONFIG_XENO_OPT_VFILE */
	return 0;
#endif /* CONFIG_XENO_OPT_VFILE */
}

/***
 *  rt_ip_routing_realease
 */
void rt_ip_routing_release(void)
{
#ifdef CONFIG_XENO_OPT_VFILE
	rt_route_proc_unregister();
#endif /* CONFIG_XENO_OPT_VFILE */
}

EXPORT_SYMBOL_GPL(rt_ip_route_add_host);
EXPORT_SYMBOL_GPL(rt_ip_route_del_host);
EXPORT_SYMBOL_GPL(rt_ip_route_del_all);
EXPORT_SYMBOL_GPL(rt_ip_route_output);