Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4e902c57 authored by Thomas Graf's avatar Thomas Graf Committed by David S. Miller
Browse files

[IPv4]: FIB configuration using struct fib_config 



Introduces struct fib_config replacing the ugly struct kern_rta
prone to ordering issues. Avoids creating faked netlink messages
for auto generated routes or requests via ioctl.

A new interface net/nexthop.h is added to help navigate through
nexthop configuration arrays.

A new struct nl_info will be used to carry the necessary netlink
information to be used for notifications later on.

Signed-off-by: default avatarThomas Graf <tgraf@suug.ch>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent ab32ea5d

include/net/ip_fib.h

+28 −27
Original line number Diff line number Diff line
@@ -20,24 +20,31 @@ 
#include <linux/seq_file.h>

#include <net/fib_rules.h>



/* WARNING: The ordering of these elements must match ordering

 *          of RTA_* rtnetlink attribute numbers.

 */

struct kern_rta {

	void		*rta_dst;

	void		*rta_src;

	int		*rta_iif;

	int		*rta_oif;

	void		*rta_gw;

	u32		*rta_priority;

	void		*rta_prefsrc;

	struct rtattr	*rta_mx;

	struct rtattr	*rta_mp;

	unsigned char	*rta_protoinfo;

	u32		*rta_flow;

	struct rta_cacheinfo *rta_ci;

	struct rta_session *rta_sess;

	u32		*rta_mp_alg;

struct fib_config {

	u8			fc_family;

	u8			fc_dst_len;

	u8			fc_src_len;

	u8			fc_tos;

	u8			fc_protocol;

	u8			fc_scope;

	u8			fc_type;

	/* 1 byte unused */

	u32			fc_table;

	u32			fc_dst;

	u32			fc_src;

	u32			fc_gw;

	int			fc_oif;

	u32			fc_flags;

	u32			fc_priority;

	u32			fc_prefsrc;

	struct nlattr		*fc_mx;

	struct rtnexthop	*fc_mp;

	int			fc_mx_len;

	int			fc_mp_len;

	u32			fc_flow;

	u32			fc_mp_alg;

	u32			fc_nlflags;

	struct nl_info		fc_nlinfo;

 };



struct fib_info;
@@ -154,12 +161,8 @@ struct fib_table { 
	u32		tb_id;

	unsigned	tb_stamp;

	int		(*tb_lookup)(struct fib_table *tb, const struct flowi *flp, struct fib_result *res);

	int		(*tb_insert)(struct fib_table *table, struct rtmsg *r,

				     struct kern_rta *rta, struct nlmsghdr *n,

				     struct netlink_skb_parms *req);

	int		(*tb_delete)(struct fib_table *table, struct rtmsg *r,

				     struct kern_rta *rta, struct nlmsghdr *n,

				     struct netlink_skb_parms *req);

	int		(*tb_insert)(struct fib_table *, struct fib_config *);

	int		(*tb_delete)(struct fib_table *, struct fib_config *);

	int		(*tb_dump)(struct fib_table *table, struct sk_buff *skb,

				     struct netlink_callback *cb);

	int		(*tb_flush)(struct fib_table *table);
@@ -228,8 +231,6 @@ struct rtentry; 
extern int ip_fib_check_default(u32 gw, struct net_device *dev);

extern int fib_sync_down(u32 local, struct net_device *dev, int force);

extern int fib_sync_up(struct net_device *dev);

extern int fib_convert_rtentry(int cmd, struct nlmsghdr *nl, struct rtmsg *rtm,

			       struct kern_rta *rta, struct rtentry *r);

extern u32  __fib_res_prefsrc(struct fib_result *res);



/* Exported by fib_hash.c */

include/net/netlink.h

+10 −0
Original line number Diff line number Diff line
@@ -192,6 +192,16 @@ struct nla_policy { 
	u16		minlen;

};



/**

 * struct nl_info - netlink source information

 * @nlh: Netlink message header of original request

 * @pid: Netlink PID of requesting application

 */

struct nl_info {

	struct nlmsghdr		*nlh;

	u32			pid;

};



extern void		netlink_run_queue(struct sock *sk, unsigned int *qlen,

					  int (*cb)(struct sk_buff *,

						    struct nlmsghdr *, int *));

include/net/nexthop.h

0 → 100644
+33 −0
Original line number Diff line number Diff line 
#ifndef __NET_NEXTHOP_H

#define __NET_NEXTHOP_H



#include <linux/rtnetlink.h>

#include <net/netlink.h>



static inline int rtnh_ok(const struct rtnexthop *rtnh, int remaining)

{

	return remaining >= sizeof(*rtnh) &&

	       rtnh->rtnh_len >= sizeof(*rtnh) &&

	       rtnh->rtnh_len <= remaining;

}



static inline struct rtnexthop *rtnh_next(const struct rtnexthop *rtnh,

                                         int *remaining)

{

	int totlen = NLA_ALIGN(rtnh->rtnh_len);



	*remaining -= totlen;

	return (struct rtnexthop *) ((char *) rtnh + totlen);

}



static inline struct nlattr *rtnh_attrs(const struct rtnexthop *rtnh)

{

	return (struct nlattr *) ((char *) rtnh + NLA_ALIGN(sizeof(*rtnh)));

}



static inline int rtnh_attrlen(const struct rtnexthop *rtnh)

{

	return rtnh->rtnh_len - NLA_ALIGN(sizeof(*rtnh));

}



#endif

net/ipv4/fib_frontend.c

+294 −70
Original line number Diff line number Diff line
@@ -253,42 +253,190 @@ e_inval: 


#ifndef CONFIG_IP_NOSIOCRT



static inline u32 sk_extract_addr(struct sockaddr *addr)

{

	return ((struct sockaddr_in *) addr)->sin_addr.s_addr;

}



static int put_rtax(struct nlattr *mx, int len, int type, u32 value)

{

	struct nlattr *nla;



	nla = (struct nlattr *) ((char *) mx + len);

	nla->nla_type = type;

	nla->nla_len = nla_attr_size(4);

	*(u32 *) nla_data(nla) = value;



	return len + nla_total_size(4);

}



static int rtentry_to_fib_config(int cmd, struct rtentry *rt,

				 struct fib_config *cfg)

{

	u32 addr;

	int plen;



	memset(cfg, 0, sizeof(*cfg));



	if (rt->rt_dst.sa_family != AF_INET)

		return -EAFNOSUPPORT;



	/*

	 * Check mask for validity:

	 * a) it must be contiguous.

	 * b) destination must have all host bits clear.

	 * c) if application forgot to set correct family (AF_INET),

	 *    reject request unless it is absolutely clear i.e.

	 *    both family and mask are zero.

	 */

	plen = 32;

	addr = sk_extract_addr(&rt->rt_dst);

	if (!(rt->rt_flags & RTF_HOST)) {

		u32 mask = sk_extract_addr(&rt->rt_genmask);



		if (rt->rt_genmask.sa_family != AF_INET) {

			if (mask || rt->rt_genmask.sa_family)

				return -EAFNOSUPPORT;

		}



		if (bad_mask(mask, addr))

			return -EINVAL;



		plen = inet_mask_len(mask);

	}



	cfg->fc_dst_len = plen;

	cfg->fc_dst = addr;



	if (cmd != SIOCDELRT) {

		cfg->fc_nlflags = NLM_F_CREATE;

		cfg->fc_protocol = RTPROT_BOOT;

	}



	if (rt->rt_metric)

		cfg->fc_priority = rt->rt_metric - 1;



	if (rt->rt_flags & RTF_REJECT) {

		cfg->fc_scope = RT_SCOPE_HOST;

		cfg->fc_type = RTN_UNREACHABLE;

		return 0;

	}



	cfg->fc_scope = RT_SCOPE_NOWHERE;

	cfg->fc_type = RTN_UNICAST;



	if (rt->rt_dev) {

		char *colon;

		struct net_device *dev;

		char devname[IFNAMSIZ];



		if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))

			return -EFAULT;



		devname[IFNAMSIZ-1] = 0;

		colon = strchr(devname, ':');

		if (colon)

			*colon = 0;

		dev = __dev_get_by_name(devname);

		if (!dev)

			return -ENODEV;

		cfg->fc_oif = dev->ifindex;

		if (colon) {

			struct in_ifaddr *ifa;

			struct in_device *in_dev = __in_dev_get_rtnl(dev);

			if (!in_dev)

				return -ENODEV;

			*colon = ':';

			for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)

				if (strcmp(ifa->ifa_label, devname) == 0)

					break;

			if (ifa == NULL)

				return -ENODEV;

			cfg->fc_prefsrc = ifa->ifa_local;

		}

	}



	addr = sk_extract_addr(&rt->rt_gateway);

	if (rt->rt_gateway.sa_family == AF_INET && addr) {

		cfg->fc_gw = addr;

		if (rt->rt_flags & RTF_GATEWAY &&

		    inet_addr_type(addr) == RTN_UNICAST)

			cfg->fc_scope = RT_SCOPE_UNIVERSE;

	}



	if (cmd == SIOCDELRT)

		return 0;



	if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)

		return -EINVAL;



	if (cfg->fc_scope == RT_SCOPE_NOWHERE)

		cfg->fc_scope = RT_SCOPE_LINK;



	if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {

		struct nlattr *mx;

		int len = 0;



		mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);

 		if (mx == NULL)

			return -ENOMEM;



		if (rt->rt_flags & RTF_MTU)

			len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);



		if (rt->rt_flags & RTF_WINDOW)

			len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);



		if (rt->rt_flags & RTF_IRTT)

			len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);



		cfg->fc_mx = mx;

		cfg->fc_mx_len = len;

	}



	return 0;

}



/*

 *	Handle IP routing ioctl calls. These are used to manipulate the routing tables

 */

 

int ip_rt_ioctl(unsigned int cmd, void __user *arg)

{

	struct fib_config cfg;

	struct rtentry rt;

	int err;

	struct kern_rta rta;

	struct rtentry  r;

	struct {

		struct nlmsghdr nlh;

		struct rtmsg	rtm;

	} req;



	switch (cmd) {

	case SIOCADDRT:		/* Add a route */

	case SIOCDELRT:		/* Delete a route */

		if (!capable(CAP_NET_ADMIN))

			return -EPERM;

		if (copy_from_user(&r, arg, sizeof(struct rtentry)))



		if (copy_from_user(&rt, arg, sizeof(rt)))

			return -EFAULT;



		rtnl_lock();

		err = fib_convert_rtentry(cmd, &req.nlh, &req.rtm, &rta, &r);

		err = rtentry_to_fib_config(cmd, &rt, &cfg);

		if (err == 0) {

			struct fib_table *tb;



			if (cmd == SIOCDELRT) {

				struct fib_table *tb = fib_get_table(req.rtm.rtm_table);

				err = -ESRCH;

				tb = fib_get_table(cfg.fc_table);

				if (tb)

					err = tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);

					err = tb->tb_delete(tb, &cfg);

				else

					err = -ESRCH;

			} else {

				struct fib_table *tb = fib_new_table(req.rtm.rtm_table);

				err = -ENOBUFS;

				tb = fib_new_table(cfg.fc_table);

				if (tb)

					err = tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);

					err = tb->tb_insert(tb, &cfg);

				else

					err = -ENOBUFS;

			}

			kfree(rta.rta_mx);



			/* allocated by rtentry_to_fib_config() */

			kfree(cfg.fc_mx);

		}

		rtnl_unlock();

		return err;
@@ -305,51 +453,134 @@ int ip_rt_ioctl(unsigned int cmd, void *arg) 


#endif



static int inet_check_attr(struct rtmsg *r, struct rtattr **rta)

{

	int i;

static struct nla_policy rtm_ipv4_policy[RTA_MAX+1] __read_mostly = {

	[RTA_DST]		= { .type = NLA_U32 },

	[RTA_SRC]		= { .type = NLA_U32 },

	[RTA_IIF]		= { .type = NLA_U32 },

	[RTA_OIF]		= { .type = NLA_U32 },

	[RTA_GATEWAY]		= { .type = NLA_U32 },

	[RTA_PRIORITY]		= { .type = NLA_U32 },

	[RTA_PREFSRC]		= { .type = NLA_U32 },

	[RTA_METRICS]		= { .type = NLA_NESTED },

	[RTA_MULTIPATH]		= { .minlen = sizeof(struct rtnexthop) },

	[RTA_PROTOINFO]		= { .type = NLA_U32 },

	[RTA_FLOW]		= { .type = NLA_U32 },

	[RTA_MP_ALGO]		= { .type = NLA_U32 },

};



	for (i=1; i<=RTA_MAX; i++, rta++) {

		struct rtattr *attr = *rta;

		if (attr) {

			if (RTA_PAYLOAD(attr) < 4)

				return -EINVAL;

			if (i != RTA_MULTIPATH && i != RTA_METRICS &&

			    i != RTA_TABLE)

				*rta = (struct rtattr*)RTA_DATA(attr);

static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,

			     struct fib_config *cfg)

{

	struct nlattr *attr;

	int err, remaining;

	struct rtmsg *rtm;



	err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);

	if (err < 0)

		goto errout;



	memset(cfg, 0, sizeof(*cfg));



	rtm = nlmsg_data(nlh);

	cfg->fc_family = rtm->rtm_family;

	cfg->fc_dst_len = rtm->rtm_dst_len;

	cfg->fc_src_len = rtm->rtm_src_len;

	cfg->fc_tos = rtm->rtm_tos;

	cfg->fc_table = rtm->rtm_table;

	cfg->fc_protocol = rtm->rtm_protocol;

	cfg->fc_scope = rtm->rtm_scope;

	cfg->fc_type = rtm->rtm_type;

	cfg->fc_flags = rtm->rtm_flags;

	cfg->fc_nlflags = nlh->nlmsg_flags;



	cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;

	cfg->fc_nlinfo.nlh = nlh;



	nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {

		switch (attr->nla_type) {

		case RTA_DST:

			cfg->fc_dst = nla_get_u32(attr);

			break;

		case RTA_SRC:

			cfg->fc_src = nla_get_u32(attr);

			break;

		case RTA_OIF:

			cfg->fc_oif = nla_get_u32(attr);

			break;

		case RTA_GATEWAY:

			cfg->fc_gw = nla_get_u32(attr);

			break;

		case RTA_PRIORITY:

			cfg->fc_priority = nla_get_u32(attr);

			break;

		case RTA_PREFSRC:

			cfg->fc_prefsrc = nla_get_u32(attr);

			break;

		case RTA_METRICS:

			cfg->fc_mx = nla_data(attr);

			cfg->fc_mx_len = nla_len(attr);

			break;

		case RTA_MULTIPATH:

			cfg->fc_mp = nla_data(attr);

			cfg->fc_mp_len = nla_len(attr);

			break;

		case RTA_FLOW:

			cfg->fc_flow = nla_get_u32(attr);

			break;

		case RTA_MP_ALGO:

			cfg->fc_mp_alg = nla_get_u32(attr);

			break;

		case RTA_TABLE:

			cfg->fc_table = nla_get_u32(attr);

			break;

		}

	}



	return 0;

errout:

	return err;

}



int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)

{

	struct fib_config cfg;

	struct fib_table *tb;

	struct rtattr **rta = arg;

	struct rtmsg *r = NLMSG_DATA(nlh);

	int err;



	if (inet_check_attr(r, rta))

		return -EINVAL;

	err = rtm_to_fib_config(skb, nlh, &cfg);

	if (err < 0)

		goto errout;



	tb = fib_get_table(rtm_get_table(rta, r->rtm_table));

	if (tb)

		return tb->tb_delete(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));

	return -ESRCH;

	tb = fib_get_table(cfg.fc_table);

	if (tb == NULL) {

		err = -ESRCH;

		goto errout;

	}



	err = tb->tb_delete(tb, &cfg);

errout:

	return err;

}



int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)

{

	struct fib_config cfg;

	struct fib_table *tb;

	struct rtattr **rta = arg;

	struct rtmsg *r = NLMSG_DATA(nlh);

	int err;



	if (inet_check_attr(r, rta))

		return -EINVAL;

	err = rtm_to_fib_config(skb, nlh, &cfg);

	if (err < 0)

		goto errout;



	tb = fib_new_table(rtm_get_table(rta, r->rtm_table));

	if (tb)

		return tb->tb_insert(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));

	return -ENOBUFS;

	tb = fib_new_table(cfg.fc_table);

	if (tb == NULL) {

		err = -ENOBUFS;

		goto errout;

	}



	err = tb->tb_insert(tb, &cfg);

errout:

	return err;

}



int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
@@ -396,17 +627,19 @@ out: 
   only when netlink is already locked.

 */



static void fib_magic(int cmd, int type, u32 dst, int dst_len, struct in_ifaddr *ifa)

static void fib_magic(int cmd, int type, u32 dst, int dst_len,

		      struct in_ifaddr *ifa)

{

	struct fib_table *tb;

	struct {

		struct nlmsghdr	nlh;

		struct rtmsg	rtm;

	} req;

	struct kern_rta rta;



	memset(&req.rtm, 0, sizeof(req.rtm));

	memset(&rta, 0, sizeof(rta));

	struct fib_config cfg = {

		.fc_protocol = RTPROT_KERNEL,

		.fc_type = type,

		.fc_dst = dst,

		.fc_dst_len = dst_len,

		.fc_prefsrc = ifa->ifa_local,

		.fc_oif = ifa->ifa_dev->dev->ifindex,

		.fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,

	};



	if (type == RTN_UNICAST)

		tb = fib_new_table(RT_TABLE_MAIN);
@@ -416,26 +649,17 @@ static void fib_magic(int cmd, int type, u32 dst, int dst_len, struct in_ifaddr 
	if (tb == NULL)

		return;



	req.nlh.nlmsg_len = sizeof(req);

	req.nlh.nlmsg_type = cmd;

	req.nlh.nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE|NLM_F_APPEND;

	req.nlh.nlmsg_pid = 0;

	req.nlh.nlmsg_seq = 0;



	req.rtm.rtm_dst_len = dst_len;

	req.rtm.rtm_table = tb->tb_id;

	req.rtm.rtm_protocol = RTPROT_KERNEL;

	req.rtm.rtm_scope = (type != RTN_LOCAL ? RT_SCOPE_LINK : RT_SCOPE_HOST);

	req.rtm.rtm_type = type;

	cfg.fc_table = tb->tb_id;



	rta.rta_dst = &dst;

	rta.rta_prefsrc = &ifa->ifa_local;

	rta.rta_oif = &ifa->ifa_dev->dev->ifindex;

	if (type != RTN_LOCAL)

		cfg.fc_scope = RT_SCOPE_LINK;

	else

		cfg.fc_scope = RT_SCOPE_HOST;



	if (cmd == RTM_NEWROUTE)

		tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);

		tb->tb_insert(tb, &cfg);

	else

		tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);

		tb->tb_delete(tb, &cfg);

}



void fib_add_ifaddr(struct in_ifaddr *ifa)

net/ipv4/fib_hash.c

+44 −50
Original line number Diff line number Diff line
@@ -379,42 +379,39 @@ static struct fib_node *fib_find_node(struct fn_zone *fz, u32 key) 
	return NULL;

}



static int

fn_hash_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,

	       struct nlmsghdr *n, struct netlink_skb_parms *req)

static int fn_hash_insert(struct fib_table *tb, struct fib_config *cfg)

{

	struct fn_hash *table = (struct fn_hash *) tb->tb_data;

	struct fib_node *new_f, *f;

	struct fib_alias *fa, *new_fa;

	struct fn_zone *fz;

	struct fib_info *fi;

	int z = r->rtm_dst_len;

	int type = r->rtm_type;

	u8 tos = r->rtm_tos;

	u8 tos = cfg->fc_tos;

	u32 key;

	int err;



	if (z > 32)

	if (cfg->fc_dst_len > 32)

		return -EINVAL;

	fz = table->fn_zones[z];

	if (!fz && !(fz = fn_new_zone(table, z)))



	fz = table->fn_zones[cfg->fc_dst_len];

	if (!fz && !(fz = fn_new_zone(table, cfg->fc_dst_len)))

		return -ENOBUFS;



	key = 0;

	if (rta->rta_dst) {

		u32 dst;

		memcpy(&dst, rta->rta_dst, 4);

		if (dst & ~FZ_MASK(fz))

	if (cfg->fc_dst) {

		if (cfg->fc_dst & ~FZ_MASK(fz))

			return -EINVAL;

		key = fz_key(dst, fz);

		key = fz_key(cfg->fc_dst, fz);

	}



	if  ((fi = fib_create_info(r, rta, n, &err)) == NULL)

		return err;

	fi = fib_create_info(cfg);

	if (IS_ERR(fi))

		return PTR_ERR(fi);



	if (fz->fz_nent > (fz->fz_divisor<<1) &&

	    fz->fz_divisor < FZ_MAX_DIVISOR &&

	    (z==32 || (1<<z) > fz->fz_divisor))

	    (cfg->fc_dst_len == 32 ||

	     (1 << cfg->fc_dst_len) > fz->fz_divisor))

		fn_rehash_zone(fz);



	f = fib_find_node(fz, key);
@@ -440,18 +437,18 @@ fn_hash_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 
		struct fib_alias *fa_orig;



		err = -EEXIST;

		if (n->nlmsg_flags & NLM_F_EXCL)

		if (cfg->fc_nlflags & NLM_F_EXCL)

			goto out;



		if (n->nlmsg_flags & NLM_F_REPLACE) {

		if (cfg->fc_nlflags & NLM_F_REPLACE) {

			struct fib_info *fi_drop;

			u8 state;



			write_lock_bh(&fib_hash_lock);

			fi_drop = fa->fa_info;

			fa->fa_info = fi;

			fa->fa_type = type;

			fa->fa_scope = r->rtm_scope;

			fa->fa_type = cfg->fc_type;

			fa->fa_scope = cfg->fc_scope;

			state = fa->fa_state;

			fa->fa_state &= ~FA_S_ACCESSED;

			fib_hash_genid++;
@@ -474,17 +471,17 @@ fn_hash_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 
				break;

			if (fa->fa_info->fib_priority != fi->fib_priority)

				break;

			if (fa->fa_type == type &&

			    fa->fa_scope == r->rtm_scope &&

			if (fa->fa_type == cfg->fc_type &&

			    fa->fa_scope == cfg->fc_scope &&

			    fa->fa_info == fi)

				goto out;

		}

		if (!(n->nlmsg_flags & NLM_F_APPEND))

		if (!(cfg->fc_nlflags & NLM_F_APPEND))

			fa = fa_orig;

	}



	err = -ENOENT;

	if (!(n->nlmsg_flags&NLM_F_CREATE))

	if (!(cfg->fc_nlflags & NLM_F_CREATE))

		goto out;



	err = -ENOBUFS;
@@ -506,8 +503,8 @@ fn_hash_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 


	new_fa->fa_info = fi;

	new_fa->fa_tos = tos;

	new_fa->fa_type = type;

	new_fa->fa_scope = r->rtm_scope;

	new_fa->fa_type = cfg->fc_type;

	new_fa->fa_scope = cfg->fc_scope;

	new_fa->fa_state = 0;



	/*
@@ -526,7 +523,8 @@ fn_hash_insert(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 
		fz->fz_nent++;

	rt_cache_flush(-1);



	rtmsg_fib(RTM_NEWROUTE, key, new_fa, z, tb->tb_id, n, req);

	rtmsg_fib(RTM_NEWROUTE, key, new_fa, cfg->fc_dst_len, tb->tb_id,

		  &cfg->fc_nlinfo);

	return 0;



out_free_new_fa:
@@ -537,30 +535,25 @@ out: 
}





static int

fn_hash_delete(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta,

	       struct nlmsghdr *n, struct netlink_skb_parms *req)

static int fn_hash_delete(struct fib_table *tb, struct fib_config *cfg)

{

	struct fn_hash *table = (struct fn_hash*)tb->tb_data;

	struct fib_node *f;

	struct fib_alias *fa, *fa_to_delete;

	int z = r->rtm_dst_len;

	struct fn_zone *fz;

	u32 key;

	u8 tos = r->rtm_tos;



	if (z > 32)

	if (cfg->fc_dst_len > 32)

		return -EINVAL;

	if ((fz  = table->fn_zones[z]) == NULL)



	if ((fz  = table->fn_zones[cfg->fc_dst_len]) == NULL)

		return -ESRCH;



	key = 0;

	if (rta->rta_dst) {

		u32 dst;

		memcpy(&dst, rta->rta_dst, 4);

		if (dst & ~FZ_MASK(fz))

	if (cfg->fc_dst) {

		if (cfg->fc_dst & ~FZ_MASK(fz))

			return -EINVAL;

		key = fz_key(dst, fz);

		key = fz_key(cfg->fc_dst, fz);

	}



	f = fib_find_node(fz, key);
@@ -568,7 +561,7 @@ fn_hash_delete(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 
	if (!f)

		fa = NULL;

	else

		fa = fib_find_alias(&f->fn_alias, tos, 0);

		fa = fib_find_alias(&f->fn_alias, cfg->fc_tos, 0);

	if (!fa)

		return -ESRCH;
@@ -577,16 +570,16 @@ fn_hash_delete(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 
	list_for_each_entry_continue(fa, &f->fn_alias, fa_list) {

		struct fib_info *fi = fa->fa_info;



		if (fa->fa_tos != tos)

		if (fa->fa_tos != cfg->fc_tos)

			break;



		if ((!r->rtm_type ||

		     fa->fa_type == r->rtm_type) &&

		    (r->rtm_scope == RT_SCOPE_NOWHERE ||

		     fa->fa_scope == r->rtm_scope) &&

		    (!r->rtm_protocol ||

		     fi->fib_protocol == r->rtm_protocol) &&

		    fib_nh_match(r, n, rta, fi) == 0) {

		if ((!cfg->fc_type ||

		     fa->fa_type == cfg->fc_type) &&

		    (cfg->fc_scope == RT_SCOPE_NOWHERE ||

		     fa->fa_scope == cfg->fc_scope) &&

		    (!cfg->fc_protocol ||

		     fi->fib_protocol == cfg->fc_protocol) &&

		    fib_nh_match(cfg, fi) == 0) {

			fa_to_delete = fa;

			break;

		}
@@ -596,7 +589,8 @@ fn_hash_delete(struct fib_table *tb, struct rtmsg *r, struct kern_rta *rta, 
		int kill_fn;



		fa = fa_to_delete;

		rtmsg_fib(RTM_DELROUTE, key, fa, z, tb->tb_id, n, req);

		rtmsg_fib(RTM_DELROUTE, key, fa, cfg->fc_dst_len,

			  tb->tb_id, &cfg->fc_nlinfo);



		kill_fn = 0;

		write_lock_bh(&fib_hash_lock);