URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [net/] [decnet/] [dn_fib.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * DECnet       An implementation of the DECnet protocol suite for the LINUX
 *              operating system.  DECnet is implemented using the  BSD Socket
 *              interface as the means of communication with the user level.
 *
 *              DECnet Routing Forwarding Information Base (Glue/Info List)
 *
 * Author:      Steve Whitehouse <SteveW@ACM.org>
 *
 *
 * Changes:
 *              Alexey Kuznetsov : SMP locking changes
 *              Steve Whitehouse : Rewrote it... Well to be more correct, I
 *                                 copied most of it from the ipv4 fib code.
 *              Steve Whitehouse : Updated it in style and fixed a few bugs
 *                                 which were fixed in the ipv4 code since
 *                                 this code was copied from it.
 *
 */
#include <linux/string.h>
#include <linux/net.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/proc_fs.h>
#include <linux/netdevice.h>
#include <linux/timer.h>
#include <linux/spinlock.h>
#include <asm/atomic.h>
#include <asm/uaccess.h>
#include <net/neighbour.h>
#include <net/dst.h>
#include <net/flow.h>
#include <net/fib_rules.h>
#include <net/dn.h>
#include <net/dn_route.h>
#include <net/dn_fib.h>
#include <net/dn_neigh.h>
#include <net/dn_dev.h>
 
#define RT_MIN_TABLE 1
 
#define for_fib_info() { struct dn_fib_info *fi;\
        for(fi = dn_fib_info_list; fi; fi = fi->fib_next)
#define endfor_fib_info() }
 
#define for_nexthops(fi) { int nhsel; const struct dn_fib_nh *nh;\
        for(nhsel = 0, nh = (fi)->fib_nh; nhsel < (fi)->fib_nhs; nh++, nhsel++)
 
#define change_nexthops(fi) { int nhsel; struct dn_fib_nh *nh;\
        for(nhsel = 0, nh = (struct dn_fib_nh *)((fi)->fib_nh); nhsel < (fi)->fib_nhs; nh++, nhsel++)
 
#define endfor_nexthops(fi) }
 
static DEFINE_SPINLOCK(dn_fib_multipath_lock);
static struct dn_fib_info *dn_fib_info_list;
static DEFINE_SPINLOCK(dn_fib_info_lock);
 
static struct
{
        int error;
        u8 scope;
} dn_fib_props[RTN_MAX+1] = {
        [RTN_UNSPEC] =      { .error = 0,       .scope = RT_SCOPE_NOWHERE },
        [RTN_UNICAST] =     { .error = 0,       .scope = RT_SCOPE_UNIVERSE },
        [RTN_LOCAL] =       { .error = 0,       .scope = RT_SCOPE_HOST },
        [RTN_BROADCAST] =   { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },
        [RTN_ANYCAST] =     { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },
        [RTN_MULTICAST] =   { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },
        [RTN_BLACKHOLE] =   { .error = -EINVAL, .scope = RT_SCOPE_UNIVERSE },
        [RTN_UNREACHABLE] = { .error = -EHOSTUNREACH, .scope = RT_SCOPE_UNIVERSE },
        [RTN_PROHIBIT] =    { .error = -EACCES, .scope = RT_SCOPE_UNIVERSE },
        [RTN_THROW] =       { .error = -EAGAIN, .scope = RT_SCOPE_UNIVERSE },
        [RTN_NAT] =         { .error = 0,       .scope = RT_SCOPE_NOWHERE },
        [RTN_XRESOLVE] =    { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },
};
 
static int dn_fib_sync_down(__le16 local, struct net_device *dev, int force);
static int dn_fib_sync_up(struct net_device *dev);
 
void dn_fib_free_info(struct dn_fib_info *fi)
{
        if (fi->fib_dead == 0) {
                printk(KERN_DEBUG "DECnet: BUG! Attempt to free alive dn_fib_info\n");
                return;
        }
 
        change_nexthops(fi) {
                if (nh->nh_dev)
                        dev_put(nh->nh_dev);
                nh->nh_dev = NULL;
        } endfor_nexthops(fi);
        kfree(fi);
}
 
void dn_fib_release_info(struct dn_fib_info *fi)
{
        spin_lock(&dn_fib_info_lock);
        if (fi && --fi->fib_treeref == 0) {
                if (fi->fib_next)
                        fi->fib_next->fib_prev = fi->fib_prev;
                if (fi->fib_prev)
                        fi->fib_prev->fib_next = fi->fib_next;
                if (fi == dn_fib_info_list)
                        dn_fib_info_list = fi->fib_next;
                fi->fib_dead = 1;
                dn_fib_info_put(fi);
        }
        spin_unlock(&dn_fib_info_lock);
}
 
static inline int dn_fib_nh_comp(const struct dn_fib_info *fi, const struct dn_fib_info *ofi)
{
        const struct dn_fib_nh *onh = ofi->fib_nh;
 
        for_nexthops(fi) {
                if (nh->nh_oif != onh->nh_oif ||
                        nh->nh_gw != onh->nh_gw ||
                        nh->nh_scope != onh->nh_scope ||
                        nh->nh_weight != onh->nh_weight ||
                        ((nh->nh_flags^onh->nh_flags)&~RTNH_F_DEAD))
                                return -1;
                onh++;
        } endfor_nexthops(fi);
        return 0;
}
 
static inline struct dn_fib_info *dn_fib_find_info(const struct dn_fib_info *nfi)
{
        for_fib_info() {
                if (fi->fib_nhs != nfi->fib_nhs)
                        continue;
                if (nfi->fib_protocol == fi->fib_protocol &&
                        nfi->fib_prefsrc == fi->fib_prefsrc &&
                        nfi->fib_priority == fi->fib_priority &&
                        memcmp(nfi->fib_metrics, fi->fib_metrics, sizeof(fi->fib_metrics)) == 0 &&
                        ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_DEAD) == 0 &&
                        (nfi->fib_nhs == 0 || dn_fib_nh_comp(fi, nfi) == 0))
                                return fi;
        } endfor_fib_info();
        return NULL;
}
 
__le16 dn_fib_get_attr16(struct rtattr *attr, int attrlen, int type)
{
        while(RTA_OK(attr,attrlen)) {
                if (attr->rta_type == type)
                        return *(__le16*)RTA_DATA(attr);
                attr = RTA_NEXT(attr, attrlen);
        }
 
        return 0;
}
 
static int dn_fib_count_nhs(struct rtattr *rta)
{
        int nhs = 0;
        struct rtnexthop *nhp = RTA_DATA(rta);
        int nhlen = RTA_PAYLOAD(rta);
 
        while(nhlen >= (int)sizeof(struct rtnexthop)) {
                if ((nhlen -= nhp->rtnh_len) < 0)
                        return 0;
                nhs++;
                nhp = RTNH_NEXT(nhp);
        }
 
        return nhs;
}
 
static int dn_fib_get_nhs(struct dn_fib_info *fi, const struct rtattr *rta, const struct rtmsg *r)
{
        struct rtnexthop *nhp = RTA_DATA(rta);
        int nhlen = RTA_PAYLOAD(rta);
 
        change_nexthops(fi) {
                int attrlen = nhlen - sizeof(struct rtnexthop);
                if (attrlen < 0 || (nhlen -= nhp->rtnh_len) < 0)
                        return -EINVAL;
 
                nh->nh_flags  = (r->rtm_flags&~0xFF) | nhp->rtnh_flags;
                nh->nh_oif    = nhp->rtnh_ifindex;
                nh->nh_weight = nhp->rtnh_hops + 1;
 
                if (attrlen) {
                        nh->nh_gw = dn_fib_get_attr16(RTNH_DATA(nhp), attrlen, RTA_GATEWAY);
                }
                nhp = RTNH_NEXT(nhp);
        } endfor_nexthops(fi);
 
        return 0;
}
 
 
static int dn_fib_check_nh(const struct rtmsg *r, struct dn_fib_info *fi, struct dn_fib_nh *nh)
{
        int err;
 
        if (nh->nh_gw) {
                struct flowi fl;
                struct dn_fib_res res;
 
                memset(&fl, 0, sizeof(fl));
 
                if (nh->nh_flags&RTNH_F_ONLINK) {
                        struct net_device *dev;
 
                        if (r->rtm_scope >= RT_SCOPE_LINK)
                                return -EINVAL;
                        if (dnet_addr_type(nh->nh_gw) != RTN_UNICAST)
                                return -EINVAL;
                        if ((dev = __dev_get_by_index(&init_net, nh->nh_oif)) == NULL)
                                return -ENODEV;
                        if (!(dev->flags&IFF_UP))
                                return -ENETDOWN;
                        nh->nh_dev = dev;
                        dev_hold(dev);
                        nh->nh_scope = RT_SCOPE_LINK;
                        return 0;
                }
 
                memset(&fl, 0, sizeof(fl));
                fl.fld_dst = nh->nh_gw;
                fl.oif = nh->nh_oif;
                fl.fld_scope = r->rtm_scope + 1;
 
                if (fl.fld_scope < RT_SCOPE_LINK)
                        fl.fld_scope = RT_SCOPE_LINK;
 
                if ((err = dn_fib_lookup(&fl, &res)) != 0)
                        return err;
 
                err = -EINVAL;
                if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
                        goto out;
                nh->nh_scope = res.scope;
                nh->nh_oif = DN_FIB_RES_OIF(res);
                nh->nh_dev = DN_FIB_RES_DEV(res);
                if (nh->nh_dev == NULL)
                        goto out;
                dev_hold(nh->nh_dev);
                err = -ENETDOWN;
                if (!(nh->nh_dev->flags & IFF_UP))
                        goto out;
                err = 0;
out:
                dn_fib_res_put(&res);
                return err;
        } else {
                struct net_device *dev;
 
                if (nh->nh_flags&(RTNH_F_PERVASIVE|RTNH_F_ONLINK))
                        return -EINVAL;
 
                dev = __dev_get_by_index(&init_net, nh->nh_oif);
                if (dev == NULL || dev->dn_ptr == NULL)
                        return -ENODEV;
                if (!(dev->flags&IFF_UP))
                        return -ENETDOWN;
                nh->nh_dev = dev;
                dev_hold(nh->nh_dev);
                nh->nh_scope = RT_SCOPE_HOST;
        }
 
        return 0;
}
 
 
struct dn_fib_info *dn_fib_create_info(const struct rtmsg *r, struct dn_kern_rta *rta, const struct nlmsghdr *nlh, int *errp)
{
        int err;
        struct dn_fib_info *fi = NULL;
        struct dn_fib_info *ofi;
        int nhs = 1;
 
        if (r->rtm_type > RTN_MAX)
                goto err_inval;
 
        if (dn_fib_props[r->rtm_type].scope > r->rtm_scope)
                goto err_inval;
 
        if (rta->rta_mp) {
                nhs = dn_fib_count_nhs(rta->rta_mp);
                if (nhs == 0)
                        goto err_inval;
        }
 
        fi = kzalloc(sizeof(*fi)+nhs*sizeof(struct dn_fib_nh), GFP_KERNEL);
        err = -ENOBUFS;
        if (fi == NULL)
                goto failure;
 
        fi->fib_protocol = r->rtm_protocol;
        fi->fib_nhs = nhs;
        fi->fib_flags = r->rtm_flags;
        if (rta->rta_priority)
                fi->fib_priority = *rta->rta_priority;
        if (rta->rta_mx) {
                int attrlen = RTA_PAYLOAD(rta->rta_mx);
                struct rtattr *attr = RTA_DATA(rta->rta_mx);
 
                while(RTA_OK(attr, attrlen)) {
                        unsigned flavour = attr->rta_type;
                        if (flavour) {
                                if (flavour > RTAX_MAX)
                                        goto err_inval;
                                fi->fib_metrics[flavour-1] = *(unsigned*)RTA_DATA(attr);
                        }
                        attr = RTA_NEXT(attr, attrlen);
                }
        }
        if (rta->rta_prefsrc)
                memcpy(&fi->fib_prefsrc, rta->rta_prefsrc, 2);
 
        if (rta->rta_mp) {
                if ((err = dn_fib_get_nhs(fi, rta->rta_mp, r)) != 0)
                        goto failure;
                if (rta->rta_oif && fi->fib_nh->nh_oif != *rta->rta_oif)
                        goto err_inval;
                if (rta->rta_gw && memcmp(&fi->fib_nh->nh_gw, rta->rta_gw, 2))
                        goto err_inval;
        } else {
                struct dn_fib_nh *nh = fi->fib_nh;
                if (rta->rta_oif)
                        nh->nh_oif = *rta->rta_oif;
                if (rta->rta_gw)
                        memcpy(&nh->nh_gw, rta->rta_gw, 2);
                nh->nh_flags = r->rtm_flags;
                nh->nh_weight = 1;
        }
 
        if (r->rtm_type == RTN_NAT) {
                if (rta->rta_gw == NULL || nhs != 1 || rta->rta_oif)
                        goto err_inval;
                memcpy(&fi->fib_nh->nh_gw, rta->rta_gw, 2);
                goto link_it;
        }
 
        if (dn_fib_props[r->rtm_type].error) {
                if (rta->rta_gw || rta->rta_oif || rta->rta_mp)
                        goto err_inval;
                goto link_it;
        }
 
        if (r->rtm_scope > RT_SCOPE_HOST)
                goto err_inval;
 
        if (r->rtm_scope == RT_SCOPE_HOST) {
                struct dn_fib_nh *nh = fi->fib_nh;
 
                /* Local address is added */
                if (nhs != 1 || nh->nh_gw)
                        goto err_inval;
                nh->nh_scope = RT_SCOPE_NOWHERE;
                nh->nh_dev = dev_get_by_index(&init_net, fi->fib_nh->nh_oif);
                err = -ENODEV;
                if (nh->nh_dev == NULL)
                        goto failure;
        } else {
                change_nexthops(fi) {
                        if ((err = dn_fib_check_nh(r, fi, nh)) != 0)
                                goto failure;
                } endfor_nexthops(fi)
        }
 
        if (fi->fib_prefsrc) {
                if (r->rtm_type != RTN_LOCAL || rta->rta_dst == NULL ||
                    memcmp(&fi->fib_prefsrc, rta->rta_dst, 2))
                        if (dnet_addr_type(fi->fib_prefsrc) != RTN_LOCAL)
                                goto err_inval;
        }
 
link_it:
        if ((ofi = dn_fib_find_info(fi)) != NULL) {
                fi->fib_dead = 1;
                dn_fib_free_info(fi);
                ofi->fib_treeref++;
                return ofi;
        }
 
        fi->fib_treeref++;
        atomic_inc(&fi->fib_clntref);
        spin_lock(&dn_fib_info_lock);
        fi->fib_next = dn_fib_info_list;
        fi->fib_prev = NULL;
        if (dn_fib_info_list)
                dn_fib_info_list->fib_prev = fi;
        dn_fib_info_list = fi;
        spin_unlock(&dn_fib_info_lock);
        return fi;
 
err_inval:
        err = -EINVAL;
 
failure:
        *errp = err;
        if (fi) {
                fi->fib_dead = 1;
                dn_fib_free_info(fi);
        }
 
        return NULL;
}
 
int dn_fib_semantic_match(int type, struct dn_fib_info *fi, const struct flowi *fl, struct dn_fib_res *res)
{
        int err = dn_fib_props[type].error;
 
        if (err == 0) {
                if (fi->fib_flags & RTNH_F_DEAD)
                        return 1;
 
                res->fi = fi;
 
                switch(type) {
                        case RTN_NAT:
                                DN_FIB_RES_RESET(*res);
                                atomic_inc(&fi->fib_clntref);
                                return 0;
                        case RTN_UNICAST:
                        case RTN_LOCAL:
                                for_nexthops(fi) {
                                        if (nh->nh_flags & RTNH_F_DEAD)
                                                continue;
                                        if (!fl->oif || fl->oif == nh->nh_oif)
                                                break;
                                }
                                if (nhsel < fi->fib_nhs) {
                                        res->nh_sel = nhsel;
                                        atomic_inc(&fi->fib_clntref);
                                        return 0;
                                }
                                endfor_nexthops(fi);
                                res->fi = NULL;
                                return 1;
                        default:
                                if (net_ratelimit())
                                         printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", type);
                                res->fi = NULL;
                                return -EINVAL;
                }
        }
        return err;
}
 
void dn_fib_select_multipath(const struct flowi *fl, struct dn_fib_res *res)
{
        struct dn_fib_info *fi = res->fi;
        int w;
 
        spin_lock_bh(&dn_fib_multipath_lock);
        if (fi->fib_power <= 0) {
                int power = 0;
                change_nexthops(fi) {
                        if (!(nh->nh_flags&RTNH_F_DEAD)) {
                                power += nh->nh_weight;
                                nh->nh_power = nh->nh_weight;
                        }
                } endfor_nexthops(fi);
                fi->fib_power = power;
                if (power < 0) {
                        spin_unlock_bh(&dn_fib_multipath_lock);
                        res->nh_sel = 0;
                        return;
                }
        }
 
        w = jiffies % fi->fib_power;
 
        change_nexthops(fi) {
                if (!(nh->nh_flags&RTNH_F_DEAD) && nh->nh_power) {
                        if ((w -= nh->nh_power) <= 0) {
                                nh->nh_power--;
                                fi->fib_power--;
                                res->nh_sel = nhsel;
                                spin_unlock_bh(&dn_fib_multipath_lock);
                                return;
                        }
                }
        } endfor_nexthops(fi);
        res->nh_sel = 0;
        spin_unlock_bh(&dn_fib_multipath_lock);
}
 
 
static int dn_fib_check_attr(struct rtmsg *r, struct rtattr **rta)
{
        int i;
 
        for(i = 1; i <= RTA_MAX; i++) {
                struct rtattr *attr = rta[i-1];
                if (attr) {
                        if (RTA_PAYLOAD(attr) < 4 && RTA_PAYLOAD(attr) != 2)
                                return -EINVAL;
                        if (i != RTA_MULTIPATH && i != RTA_METRICS &&
                            i != RTA_TABLE)
                                rta[i-1] = (struct rtattr *)RTA_DATA(attr);
                }
        }
 
        return 0;
}
 
static int dn_fib_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
        struct dn_fib_table *tb;
        struct rtattr **rta = arg;
        struct rtmsg *r = NLMSG_DATA(nlh);
 
        if (dn_fib_check_attr(r, rta))
                return -EINVAL;
 
        tb = dn_fib_get_table(rtm_get_table(rta, r->rtm_table), 0);
        if (tb)
                return tb->delete(tb, r, (struct dn_kern_rta *)rta, nlh, &NETLINK_CB(skb));
 
        return -ESRCH;
}
 
static int dn_fib_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
        struct dn_fib_table *tb;
        struct rtattr **rta = arg;
        struct rtmsg *r = NLMSG_DATA(nlh);
 
        if (dn_fib_check_attr(r, rta))
                return -EINVAL;
 
        tb = dn_fib_get_table(rtm_get_table(rta, r->rtm_table), 1);
        if (tb)
                return tb->insert(tb, r, (struct dn_kern_rta *)rta, nlh, &NETLINK_CB(skb));
 
        return -ENOBUFS;
}
 
static void fib_magic(int cmd, int type, __le16 dst, int dst_len, struct dn_ifaddr *ifa)
{
        struct dn_fib_table *tb;
        struct {
                struct nlmsghdr nlh;
                struct rtmsg rtm;
        } req;
        struct dn_kern_rta rta;
 
        memset(&req.rtm, 0, sizeof(req.rtm));
        memset(&rta, 0, sizeof(rta));
 
        if (type == RTN_UNICAST)
                tb = dn_fib_get_table(RT_MIN_TABLE, 1);
        else
                tb = dn_fib_get_table(RT_TABLE_LOCAL, 1);
 
        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->n;
        req.rtm.rtm_protocol = RTPROT_KERNEL;
        req.rtm.rtm_scope = (type != RTN_LOCAL ? RT_SCOPE_LINK : RT_SCOPE_HOST);
        req.rtm.rtm_type = type;
 
        rta.rta_dst = &dst;
        rta.rta_prefsrc = &ifa->ifa_local;
        rta.rta_oif = &ifa->ifa_dev->dev->ifindex;
 
        if (cmd == RTM_NEWROUTE)
                tb->insert(tb, &req.rtm, &rta, &req.nlh, NULL);
        else
                tb->delete(tb, &req.rtm, &rta, &req.nlh, NULL);
}
 
static void dn_fib_add_ifaddr(struct dn_ifaddr *ifa)
{
 
        fib_magic(RTM_NEWROUTE, RTN_LOCAL, ifa->ifa_local, 16, ifa);
 
#if 0
        if (!(dev->flags&IFF_UP))
                return;
        /* In the future, we will want to add default routes here */
 
#endif
}
 
static void dn_fib_del_ifaddr(struct dn_ifaddr *ifa)
{
        int found_it = 0;
        struct net_device *dev;
        struct dn_dev *dn_db;
        struct dn_ifaddr *ifa2;
 
        ASSERT_RTNL();
 
        /* Scan device list */
        read_lock(&dev_base_lock);
        for_each_netdev(&init_net, dev) {
                dn_db = dev->dn_ptr;
                if (dn_db == NULL)
                        continue;
                for(ifa2 = dn_db->ifa_list; ifa2; ifa2 = ifa2->ifa_next) {
                        if (ifa2->ifa_local == ifa->ifa_local) {
                                found_it = 1;
                                break;
                        }
                }
        }
        read_unlock(&dev_base_lock);
 
        if (found_it == 0) {
                fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 16, ifa);
 
                if (dnet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
                        if (dn_fib_sync_down(ifa->ifa_local, NULL, 0))
                                dn_fib_flush();
                }
        }
}
 
static void dn_fib_disable_addr(struct net_device *dev, int force)
{
        if (dn_fib_sync_down(0, dev, force))
                dn_fib_flush();
        dn_rt_cache_flush(0);
        neigh_ifdown(&dn_neigh_table, dev);
}
 
static int dn_fib_dnaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
{
        struct dn_ifaddr *ifa = (struct dn_ifaddr *)ptr;
 
        switch(event) {
                case NETDEV_UP:
                        dn_fib_add_ifaddr(ifa);
                        dn_fib_sync_up(ifa->ifa_dev->dev);
                        dn_rt_cache_flush(-1);
                        break;
                case NETDEV_DOWN:
                        dn_fib_del_ifaddr(ifa);
                        if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) {
                                dn_fib_disable_addr(ifa->ifa_dev->dev, 1);
                        } else {
                                dn_rt_cache_flush(-1);
                        }
                        break;
        }
        return NOTIFY_DONE;
}
 
static int dn_fib_sync_down(__le16 local, struct net_device *dev, int force)
{
        int ret = 0;
        int scope = RT_SCOPE_NOWHERE;
 
        if (force)
                scope = -1;
 
        for_fib_info() {
                /*
                 * This makes no sense for DECnet.... we will almost
                 * certainly have more than one local address the same
                 * over all our interfaces. It needs thinking about
                 * some more.
                 */
                if (local && fi->fib_prefsrc == local) {
                        fi->fib_flags |= RTNH_F_DEAD;
                        ret++;
                } else if (dev && fi->fib_nhs) {
                        int dead = 0;
 
                        change_nexthops(fi) {
                                if (nh->nh_flags&RTNH_F_DEAD)
                                        dead++;
                                else if (nh->nh_dev == dev &&
                                                nh->nh_scope != scope) {
                                        spin_lock_bh(&dn_fib_multipath_lock);
                                        nh->nh_flags |= RTNH_F_DEAD;
                                        fi->fib_power -= nh->nh_power;
                                        nh->nh_power = 0;
                                        spin_unlock_bh(&dn_fib_multipath_lock);
                                        dead++;
                                }
                        } endfor_nexthops(fi)
                        if (dead == fi->fib_nhs) {
                                fi->fib_flags |= RTNH_F_DEAD;
                                ret++;
                        }
                }
        } endfor_fib_info();
        return ret;
}
 
 
static int dn_fib_sync_up(struct net_device *dev)
{
        int ret = 0;
 
        if (!(dev->flags&IFF_UP))
                return 0;
 
        for_fib_info() {
                int alive = 0;
 
                change_nexthops(fi) {
                        if (!(nh->nh_flags&RTNH_F_DEAD)) {
                                alive++;
                                continue;
                        }
                        if (nh->nh_dev == NULL || !(nh->nh_dev->flags&IFF_UP))
                                continue;
                        if (nh->nh_dev != dev || dev->dn_ptr == NULL)
                                continue;
                        alive++;
                        spin_lock_bh(&dn_fib_multipath_lock);
                        nh->nh_power = 0;
                        nh->nh_flags &= ~RTNH_F_DEAD;
                        spin_unlock_bh(&dn_fib_multipath_lock);
                } endfor_nexthops(fi);
 
                if (alive > 0) {
                        fi->fib_flags &= ~RTNH_F_DEAD;
                        ret++;
                }
        } endfor_fib_info();
        return ret;
}
 
static struct notifier_block dn_fib_dnaddr_notifier = {
        .notifier_call = dn_fib_dnaddr_event,
};
 
void __exit dn_fib_cleanup(void)
{
        dn_fib_table_cleanup();
        dn_fib_rules_cleanup();
 
        unregister_dnaddr_notifier(&dn_fib_dnaddr_notifier);
}
 
 
void __init dn_fib_init(void)
{
        dn_fib_table_init();
        dn_fib_rules_init();
 
        register_dnaddr_notifier(&dn_fib_dnaddr_notifier);
 
        rtnl_register(PF_DECnet, RTM_NEWROUTE, dn_fib_rtm_newroute, NULL);
        rtnl_register(PF_DECnet, RTM_DELROUTE, dn_fib_rtm_delroute, NULL);
}
 
 

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [net/] [decnet/] [dn_fib.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* DECnet An implementation of the DECnet protocol suite for the LINUX`
3			`* operating system. DECnet is implemented using the BSD Socket`
4			`* interface as the means of communication with the user level.`
5			`*`
6			`* DECnet Routing Forwarding Information Base (Glue/Info List)`
7			`*`
8			`* Author: Steve Whitehouse <SteveW@ACM.org>`
9			`*`
10			`*`
11			`* Changes:`
12			`* Alexey Kuznetsov : SMP locking changes`
13			`* Steve Whitehouse : Rewrote it... Well to be more correct, I`
14			`* copied most of it from the ipv4 fib code.`
15			`* Steve Whitehouse : Updated it in style and fixed a few bugs`
16			`* which were fixed in the ipv4 code since`
17			`* this code was copied from it.`
18			`*`
19			`*/`
20			`#include <linux/string.h>`
21			`#include <linux/net.h>`
22			`#include <linux/socket.h>`
23			`#include <linux/sockios.h>`
24			`#include <linux/init.h>`
25			`#include <linux/skbuff.h>`
26			`#include <linux/netlink.h>`
27			`#include <linux/rtnetlink.h>`
28			`#include <linux/proc_fs.h>`
29			`#include <linux/netdevice.h>`
30			`#include <linux/timer.h>`
31			`#include <linux/spinlock.h>`
32			`#include <asm/atomic.h>`
33			`#include <asm/uaccess.h>`
34			`#include <net/neighbour.h>`
35			`#include <net/dst.h>`
36			`#include <net/flow.h>`
37			`#include <net/fib_rules.h>`
38			`#include <net/dn.h>`
39			`#include <net/dn_route.h>`
40			`#include <net/dn_fib.h>`
41			`#include <net/dn_neigh.h>`
42			`#include <net/dn_dev.h>`
43
44			`#define RT_MIN_TABLE 1`
45
46			`#define for_fib_info() { struct dn_fib_info *fi;\`
47			`for(fi = dn_fib_info_list; fi; fi = fi->fib_next)`
48			`#define endfor_fib_info() }`
49
50			`#define for_nexthops(fi) { int nhsel; const struct dn_fib_nh *nh;\`
51			`for(nhsel = 0, nh = (fi)->fib_nh; nhsel < (fi)->fib_nhs; nh++, nhsel++)`
52
53			`#define change_nexthops(fi) { int nhsel; struct dn_fib_nh *nh;\`
54			`for(nhsel = 0, nh = (struct dn_fib_nh *)((fi)->fib_nh); nhsel < (fi)->fib_nhs; nh++, nhsel++)`
55
56			`#define endfor_nexthops(fi) }`
57
58			`static DEFINE_SPINLOCK(dn_fib_multipath_lock);`
59			`static struct dn_fib_info *dn_fib_info_list;`
60			`static DEFINE_SPINLOCK(dn_fib_info_lock);`
61
62			`static struct`
63			`{`
64			`int error;`
65			`u8 scope;`
66			`} dn_fib_props[RTN_MAX+1] = {`
67			`[RTN_UNSPEC] = { .error = 0, .scope = RT_SCOPE_NOWHERE },`
68			`[RTN_UNICAST] = { .error = 0, .scope = RT_SCOPE_UNIVERSE },`
69			`[RTN_LOCAL] = { .error = 0, .scope = RT_SCOPE_HOST },`
70			`[RTN_BROADCAST] = { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },`
71			`[RTN_ANYCAST] = { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },`
72			`[RTN_MULTICAST] = { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },`
73			`[RTN_BLACKHOLE] = { .error = -EINVAL, .scope = RT_SCOPE_UNIVERSE },`
74			`[RTN_UNREACHABLE] = { .error = -EHOSTUNREACH, .scope = RT_SCOPE_UNIVERSE },`
75			`[RTN_PROHIBIT] = { .error = -EACCES, .scope = RT_SCOPE_UNIVERSE },`
76			`[RTN_THROW] = { .error = -EAGAIN, .scope = RT_SCOPE_UNIVERSE },`
77			`[RTN_NAT] = { .error = 0, .scope = RT_SCOPE_NOWHERE },`
78			`[RTN_XRESOLVE] = { .error = -EINVAL, .scope = RT_SCOPE_NOWHERE },`
79			`};`
80
81			`static int dn_fib_sync_down(__le16 local, struct net_device *dev, int force);`
82			`static int dn_fib_sync_up(struct net_device *dev);`
83
84			`void dn_fib_free_info(struct dn_fib_info *fi)`
85			`{`
86			`if (fi->fib_dead == 0) {`
87			`printk(KERN_DEBUG "DECnet: BUG! Attempt to free alive dn_fib_info\n");`
88			`return;`
89			`}`
90
91			`change_nexthops(fi) {`
92			`if (nh->nh_dev)`
93			`dev_put(nh->nh_dev);`
94			`nh->nh_dev = NULL;`
95			`} endfor_nexthops(fi);`
96			`kfree(fi);`
97			`}`
98
99			`void dn_fib_release_info(struct dn_fib_info *fi)`
100			`{`
101			`spin_lock(&dn_fib_info_lock);`
102			`if (fi && --fi->fib_treeref == 0) {`
103			`if (fi->fib_next)`
104			`fi->fib_next->fib_prev = fi->fib_prev;`
105			`if (fi->fib_prev)`
106			`fi->fib_prev->fib_next = fi->fib_next;`
107			`if (fi == dn_fib_info_list)`
108			`dn_fib_info_list = fi->fib_next;`
109			`fi->fib_dead = 1;`
110			`dn_fib_info_put(fi);`
111			`}`
112			`spin_unlock(&dn_fib_info_lock);`
113			`}`
114
115			`static inline int dn_fib_nh_comp(const struct dn_fib_info fi, const struct dn_fib_info ofi)`
116			`{`
117			`const struct dn_fib_nh *onh = ofi->fib_nh;`
118
119			`for_nexthops(fi) {`
120			`if (nh->nh_oif != onh->nh_oif \|\|`
121			`nh->nh_gw != onh->nh_gw \|\|`
122			`nh->nh_scope != onh->nh_scope \|\|`
123			`nh->nh_weight != onh->nh_weight \|\|`
124			`((nh->nh_flags^onh->nh_flags)&~RTNH_F_DEAD))`
125			`return -1;`
126			`onh++;`
127			`} endfor_nexthops(fi);`
128			`return 0;`
129			`}`
130
131			`static inline struct dn_fib_info dn_fib_find_info(const struct dn_fib_info nfi)`
132			`{`
133			`for_fib_info() {`
134			`if (fi->fib_nhs != nfi->fib_nhs)`
135			`continue;`
136			`if (nfi->fib_protocol == fi->fib_protocol &&`
137			`nfi->fib_prefsrc == fi->fib_prefsrc &&`
138			`nfi->fib_priority == fi->fib_priority &&`
139			`memcmp(nfi->fib_metrics, fi->fib_metrics, sizeof(fi->fib_metrics)) == 0 &&`
140			`((nfi->fib_flags^fi->fib_flags)&~RTNH_F_DEAD) == 0 &&`
141			`(nfi->fib_nhs == 0 \|\| dn_fib_nh_comp(fi, nfi) == 0))`
142			`return fi;`
143			`} endfor_fib_info();`
144			`return NULL;`
145			`}`
146
147			`__le16 dn_fib_get_attr16(struct rtattr *attr, int attrlen, int type)`
148			`{`
149			`while(RTA_OK(attr,attrlen)) {`
150			`if (attr->rta_type == type)`
151			`return (__le16)RTA_DATA(attr);`
152			`attr = RTA_NEXT(attr, attrlen);`
153			`}`
154
155			`return 0;`
156			`}`
157
158			`static int dn_fib_count_nhs(struct rtattr *rta)`
159			`{`
160			`int nhs = 0;`
161			`struct rtnexthop *nhp = RTA_DATA(rta);`
162			`int nhlen = RTA_PAYLOAD(rta);`
163
164			`while(nhlen >= (int)sizeof(struct rtnexthop)) {`
165			`if ((nhlen -= nhp->rtnh_len) < 0)`
166			`return 0;`
167			`nhs++;`
168			`nhp = RTNH_NEXT(nhp);`
169			`}`
170
171			`return nhs;`
172			`}`
173
174			`static int dn_fib_get_nhs(struct dn_fib_info fi, const struct rtattr rta, const struct rtmsg *r)`
175			`{`
176			`struct rtnexthop *nhp = RTA_DATA(rta);`
177			`int nhlen = RTA_PAYLOAD(rta);`
178
179			`change_nexthops(fi) {`
180			`int attrlen = nhlen - sizeof(struct rtnexthop);`
181			`if (attrlen < 0 \|\| (nhlen -= nhp->rtnh_len) < 0)`
182			`return -EINVAL;`
183
184			`nh->nh_flags = (r->rtm_flags&~0xFF) \| nhp->rtnh_flags;`
185			`nh->nh_oif = nhp->rtnh_ifindex;`
186			`nh->nh_weight = nhp->rtnh_hops + 1;`
187
188			`if (attrlen) {`
189			`nh->nh_gw = dn_fib_get_attr16(RTNH_DATA(nhp), attrlen, RTA_GATEWAY);`
190			`}`
191			`nhp = RTNH_NEXT(nhp);`
192			`} endfor_nexthops(fi);`
193
194			`return 0;`
195			`}`
196
197
198			`static int dn_fib_check_nh(const struct rtmsg r, struct dn_fib_info fi, struct dn_fib_nh *nh)`
199			`{`
200			`int err;`
201
202			`if (nh->nh_gw) {`
203			`struct flowi fl;`
204			`struct dn_fib_res res;`
205
206			`memset(&fl, 0, sizeof(fl));`
207
208			`if (nh->nh_flags&RTNH_F_ONLINK) {`
209			`struct net_device *dev;`
210
211			`if (r->rtm_scope >= RT_SCOPE_LINK)`
212			`return -EINVAL;`
213			`if (dnet_addr_type(nh->nh_gw) != RTN_UNICAST)`
214			`return -EINVAL;`
215			`if ((dev = __dev_get_by_index(&init_net, nh->nh_oif)) == NULL)`
216			`return -ENODEV;`
217			`if (!(dev->flags&IFF_UP))`
218			`return -ENETDOWN;`
219			`nh->nh_dev = dev;`
220			`dev_hold(dev);`
221			`nh->nh_scope = RT_SCOPE_LINK;`
222			`return 0;`
223			`}`
224
225			`memset(&fl, 0, sizeof(fl));`
226			`fl.fld_dst = nh->nh_gw;`
227			`fl.oif = nh->nh_oif;`
228			`fl.fld_scope = r->rtm_scope + 1;`
229
230			`if (fl.fld_scope < RT_SCOPE_LINK)`
231			`fl.fld_scope = RT_SCOPE_LINK;`
232
233			`if ((err = dn_fib_lookup(&fl, &res)) != 0)`
234			`return err;`
235
236			`err = -EINVAL;`
237			`if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)`
238			`goto out;`
239			`nh->nh_scope = res.scope;`
240			`nh->nh_oif = DN_FIB_RES_OIF(res);`
241			`nh->nh_dev = DN_FIB_RES_DEV(res);`
242			`if (nh->nh_dev == NULL)`
243			`goto out;`
244			`dev_hold(nh->nh_dev);`
245			`err = -ENETDOWN;`
246			`if (!(nh->nh_dev->flags & IFF_UP))`
247			`goto out;`
248			`err = 0;`
249			`out:`
250			`dn_fib_res_put(&res);`
251			`return err;`
252			`} else {`
253			`struct net_device *dev;`
254
255			`if (nh->nh_flags&(RTNH_F_PERVASIVE\|RTNH_F_ONLINK))`
256			`return -EINVAL;`
257
258			`dev = __dev_get_by_index(&init_net, nh->nh_oif);`
259			`if (dev == NULL \|\| dev->dn_ptr == NULL)`
260			`return -ENODEV;`
261			`if (!(dev->flags&IFF_UP))`
262			`return -ENETDOWN;`
263			`nh->nh_dev = dev;`
264			`dev_hold(nh->nh_dev);`
265			`nh->nh_scope = RT_SCOPE_HOST;`
266			`}`
267
268			`return 0;`
269			`}`
270
271
272			`struct dn_fib_info dn_fib_create_info(const struct rtmsg r, struct dn_kern_rta rta, const struct nlmsghdr nlh, int *errp)`
273			`{`
274			`int err;`
275			`struct dn_fib_info *fi = NULL;`
276			`struct dn_fib_info *ofi;`
277			`int nhs = 1;`
278
279			`if (r->rtm_type > RTN_MAX)`
280			`goto err_inval;`
281
282			`if (dn_fib_props[r->rtm_type].scope > r->rtm_scope)`
283			`goto err_inval;`
284
285			`if (rta->rta_mp) {`
286			`nhs = dn_fib_count_nhs(rta->rta_mp);`
287			`if (nhs == 0)`
288			`goto err_inval;`
289			`}`
290
291			`fi = kzalloc(sizeof(fi)+nhssizeof(struct dn_fib_nh), GFP_KERNEL);`
292			`err = -ENOBUFS;`
293			`if (fi == NULL)`
294			`goto failure;`
295
296			`fi->fib_protocol = r->rtm_protocol;`
297			`fi->fib_nhs = nhs;`
298			`fi->fib_flags = r->rtm_flags;`
299			`if (rta->rta_priority)`
300			`fi->fib_priority = *rta->rta_priority;`
301			`if (rta->rta_mx) {`
302			`int attrlen = RTA_PAYLOAD(rta->rta_mx);`
303			`struct rtattr *attr = RTA_DATA(rta->rta_mx);`
304
305			`while(RTA_OK(attr, attrlen)) {`
306			`unsigned flavour = attr->rta_type;`
307			`if (flavour) {`
308			`if (flavour > RTAX_MAX)`
309			`goto err_inval;`
310			`fi->fib_metrics[flavour-1] = (unsigned)RTA_DATA(attr);`
311			`}`
312			`attr = RTA_NEXT(attr, attrlen);`
313			`}`
314			`}`
315			`if (rta->rta_prefsrc)`
316			`memcpy(&fi->fib_prefsrc, rta->rta_prefsrc, 2);`
317
318			`if (rta->rta_mp) {`
319			`if ((err = dn_fib_get_nhs(fi, rta->rta_mp, r)) != 0)`
320			`goto failure;`
321			`if (rta->rta_oif && fi->fib_nh->nh_oif != *rta->rta_oif)`
322			`goto err_inval;`
323			`if (rta->rta_gw && memcmp(&fi->fib_nh->nh_gw, rta->rta_gw, 2))`
324			`goto err_inval;`
325			`} else {`
326			`struct dn_fib_nh *nh = fi->fib_nh;`
327			`if (rta->rta_oif)`
328			`nh->nh_oif = *rta->rta_oif;`
329			`if (rta->rta_gw)`
330			`memcpy(&nh->nh_gw, rta->rta_gw, 2);`
331			`nh->nh_flags = r->rtm_flags;`
332			`nh->nh_weight = 1;`
333			`}`
334
335			`if (r->rtm_type == RTN_NAT) {`
336			`if (rta->rta_gw == NULL \|\| nhs != 1 \|\| rta->rta_oif)`
337			`goto err_inval;`
338			`memcpy(&fi->fib_nh->nh_gw, rta->rta_gw, 2);`
339			`goto link_it;`
340			`}`
341
342			`if (dn_fib_props[r->rtm_type].error) {`
343			`if (rta->rta_gw \|\| rta->rta_oif \|\| rta->rta_mp)`
344			`goto err_inval;`
345			`goto link_it;`
346			`}`
347
348			`if (r->rtm_scope > RT_SCOPE_HOST)`
349			`goto err_inval;`
350
351			`if (r->rtm_scope == RT_SCOPE_HOST) {`
352			`struct dn_fib_nh *nh = fi->fib_nh;`
353
354			`/* Local address is added */`
355			`if (nhs != 1 \|\| nh->nh_gw)`
356			`goto err_inval;`
357			`nh->nh_scope = RT_SCOPE_NOWHERE;`
358			`nh->nh_dev = dev_get_by_index(&init_net, fi->fib_nh->nh_oif);`
359			`err = -ENODEV;`
360			`if (nh->nh_dev == NULL)`
361			`goto failure;`
362			`} else {`
363			`change_nexthops(fi) {`
364			`if ((err = dn_fib_check_nh(r, fi, nh)) != 0)`
365			`goto failure;`
366			`} endfor_nexthops(fi)`
367			`}`
368
369			`if (fi->fib_prefsrc) {`
370			`if (r->rtm_type != RTN_LOCAL \|\| rta->rta_dst == NULL \|\|`
371			`memcmp(&fi->fib_prefsrc, rta->rta_dst, 2))`
372			`if (dnet_addr_type(fi->fib_prefsrc) != RTN_LOCAL)`
373			`goto err_inval;`
374			`}`
375
376			`link_it:`
377			`if ((ofi = dn_fib_find_info(fi)) != NULL) {`
378			`fi->fib_dead = 1;`
379			`dn_fib_free_info(fi);`
380			`ofi->fib_treeref++;`
381			`return ofi;`
382			`}`
383
384			`fi->fib_treeref++;`
385			`atomic_inc(&fi->fib_clntref);`
386			`spin_lock(&dn_fib_info_lock);`
387			`fi->fib_next = dn_fib_info_list;`
388			`fi->fib_prev = NULL;`
389			`if (dn_fib_info_list)`
390			`dn_fib_info_list->fib_prev = fi;`
391			`dn_fib_info_list = fi;`
392			`spin_unlock(&dn_fib_info_lock);`
393			`return fi;`
394
395			`err_inval:`
396			`err = -EINVAL;`
397
398			`failure:`
399			`*errp = err;`
400			`if (fi) {`
401			`fi->fib_dead = 1;`
402			`dn_fib_free_info(fi);`
403			`}`
404
405			`return NULL;`
406			`}`
407
408			`int dn_fib_semantic_match(int type, struct dn_fib_info fi, const struct flowi fl, struct dn_fib_res *res)`
409			`{`
410			`int err = dn_fib_props[type].error;`
411
412			`if (err == 0) {`
413			`if (fi->fib_flags & RTNH_F_DEAD)`
414			`return 1;`
415
416			`res->fi = fi;`
417
418			`switch(type) {`
419			`case RTN_NAT:`
420			`DN_FIB_RES_RESET(*res);`
421			`atomic_inc(&fi->fib_clntref);`
422			`return 0;`
423			`case RTN_UNICAST:`
424			`case RTN_LOCAL:`
425			`for_nexthops(fi) {`
426			`if (nh->nh_flags & RTNH_F_DEAD)`
427			`continue;`
428			`if (!fl->oif \|\| fl->oif == nh->nh_oif)`
429			`break;`
430			`}`
431			`if (nhsel < fi->fib_nhs) {`
432			`res->nh_sel = nhsel;`
433			`atomic_inc(&fi->fib_clntref);`
434			`return 0;`
435			`}`
436			`endfor_nexthops(fi);`
437			`res->fi = NULL;`
438			`return 1;`
439			`default:`
440			`if (net_ratelimit())`
441			`printk("DECnet: impossible routing event : dn_fib_semantic_match type=%d\n", type);`
442			`res->fi = NULL;`
443			`return -EINVAL;`
444			`}`
445			`}`
446			`return err;`
447			`}`
448
449			`void dn_fib_select_multipath(const struct flowi fl, struct dn_fib_res res)`
450			`{`
451			`struct dn_fib_info *fi = res->fi;`
452			`int w;`
453
454			`spin_lock_bh(&dn_fib_multipath_lock);`
455			`if (fi->fib_power <= 0) {`
456			`int power = 0;`
457			`change_nexthops(fi) {`
458			`if (!(nh->nh_flags&RTNH_F_DEAD)) {`
459			`power += nh->nh_weight;`
460			`nh->nh_power = nh->nh_weight;`
461			`}`
462			`} endfor_nexthops(fi);`
463			`fi->fib_power = power;`
464			`if (power < 0) {`
465			`spin_unlock_bh(&dn_fib_multipath_lock);`
466			`res->nh_sel = 0;`
467			`return;`
468			`}`
469			`}`
470
471			`w = jiffies % fi->fib_power;`
472
473			`change_nexthops(fi) {`
474			`if (!(nh->nh_flags&RTNH_F_DEAD) && nh->nh_power) {`
475			`if ((w -= nh->nh_power) <= 0) {`
476			`nh->nh_power--;`
477			`fi->fib_power--;`
478			`res->nh_sel = nhsel;`
479			`spin_unlock_bh(&dn_fib_multipath_lock);`
480			`return;`
481			`}`
482			`}`
483			`} endfor_nexthops(fi);`
484			`res->nh_sel = 0;`
485			`spin_unlock_bh(&dn_fib_multipath_lock);`
486			`}`
487
488
489			`static int dn_fib_check_attr(struct rtmsg r, struct rtattr *rta)`
490			`{`
491			`int i;`
492
493			`for(i = 1; i <= RTA_MAX; i++) {`
494			`struct rtattr *attr = rta[i-1];`
495			`if (attr) {`
496			`if (RTA_PAYLOAD(attr) < 4 && RTA_PAYLOAD(attr) != 2)`
497			`return -EINVAL;`
498			`if (i != RTA_MULTIPATH && i != RTA_METRICS &&`
499			`i != RTA_TABLE)`
500			`rta[i-1] = (struct rtattr *)RTA_DATA(attr);`
501			`}`
502			`}`
503
504			`return 0;`
505			`}`
506
507			`static int dn_fib_rtm_delroute(struct sk_buff skb, struct nlmsghdr nlh, void *arg)`
508			`{`
509			`struct dn_fib_table *tb;`
510			`struct rtattr **rta = arg;`
511			`struct rtmsg *r = NLMSG_DATA(nlh);`
512
513			`if (dn_fib_check_attr(r, rta))`
514			`return -EINVAL;`
515
516			`tb = dn_fib_get_table(rtm_get_table(rta, r->rtm_table), 0);`
517			`if (tb)`
518			`return tb->delete(tb, r, (struct dn_kern_rta *)rta, nlh, &NETLINK_CB(skb));`
519
520			`return -ESRCH;`
521			`}`
522
523			`static int dn_fib_rtm_newroute(struct sk_buff skb, struct nlmsghdr nlh, void *arg)`
524			`{`
525			`struct dn_fib_table *tb;`
526			`struct rtattr **rta = arg;`
527			`struct rtmsg *r = NLMSG_DATA(nlh);`
528
529			`if (dn_fib_check_attr(r, rta))`
530			`return -EINVAL;`
531
532			`tb = dn_fib_get_table(rtm_get_table(rta, r->rtm_table), 1);`
533			`if (tb)`
534			`return tb->insert(tb, r, (struct dn_kern_rta *)rta, nlh, &NETLINK_CB(skb));`
535
536			`return -ENOBUFS;`
537			`}`
538
539			`static void fib_magic(int cmd, int type, __le16 dst, int dst_len, struct dn_ifaddr *ifa)`
540			`{`
541			`struct dn_fib_table *tb;`
542			`struct {`
543			`struct nlmsghdr nlh;`
544			`struct rtmsg rtm;`
545			`} req;`
546			`struct dn_kern_rta rta;`
547
548			`memset(&req.rtm, 0, sizeof(req.rtm));`
549			`memset(&rta, 0, sizeof(rta));`
550
551			`if (type == RTN_UNICAST)`
552			`tb = dn_fib_get_table(RT_MIN_TABLE, 1);`
553			`else`
554			`tb = dn_fib_get_table(RT_TABLE_LOCAL, 1);`
555
556			`if (tb == NULL)`
557			`return;`
558
559			`req.nlh.nlmsg_len = sizeof(req);`
560			`req.nlh.nlmsg_type = cmd;`
561			`req.nlh.nlmsg_flags = NLM_F_REQUEST\|NLM_F_CREATE\|NLM_F_APPEND;`
562			`req.nlh.nlmsg_pid = 0;`
563			`req.nlh.nlmsg_seq = 0;`
564
565			`req.rtm.rtm_dst_len = dst_len;`
566			`req.rtm.rtm_table = tb->n;`
567			`req.rtm.rtm_protocol = RTPROT_KERNEL;`
568			`req.rtm.rtm_scope = (type != RTN_LOCAL ? RT_SCOPE_LINK : RT_SCOPE_HOST);`
569			`req.rtm.rtm_type = type;`
570
571			`rta.rta_dst = &dst;`
572			`rta.rta_prefsrc = &ifa->ifa_local;`
573			`rta.rta_oif = &ifa->ifa_dev->dev->ifindex;`
574
575			`if (cmd == RTM_NEWROUTE)`
576			`tb->insert(tb, &req.rtm, &rta, &req.nlh, NULL);`
577			`else`
578			`tb->delete(tb, &req.rtm, &rta, &req.nlh, NULL);`
579			`}`
580
581			`static void dn_fib_add_ifaddr(struct dn_ifaddr *ifa)`
582			`{`
583
584			`fib_magic(RTM_NEWROUTE, RTN_LOCAL, ifa->ifa_local, 16, ifa);`
585
586			`#if 0`
587			`if (!(dev->flags&IFF_UP))`
588			`return;`
589			`/* In the future, we will want to add default routes here */`
590
591			`#endif`
592			`}`
593
594			`static void dn_fib_del_ifaddr(struct dn_ifaddr *ifa)`
595			`{`
596			`int found_it = 0;`
597			`struct net_device *dev;`
598			`struct dn_dev *dn_db;`
599			`struct dn_ifaddr *ifa2;`
600
601			`ASSERT_RTNL();`
602
603			`/* Scan device list */`
604			`read_lock(&dev_base_lock);`
605			`for_each_netdev(&init_net, dev) {`
606			`dn_db = dev->dn_ptr;`
607			`if (dn_db == NULL)`
608			`continue;`
609			`for(ifa2 = dn_db->ifa_list; ifa2; ifa2 = ifa2->ifa_next) {`
610			`if (ifa2->ifa_local == ifa->ifa_local) {`
611			`found_it = 1;`
612			`break;`
613			`}`
614			`}`
615			`}`
616			`read_unlock(&dev_base_lock);`
617
618			`if (found_it == 0) {`
619			`fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 16, ifa);`
620
621			`if (dnet_addr_type(ifa->ifa_local) != RTN_LOCAL) {`
622			`if (dn_fib_sync_down(ifa->ifa_local, NULL, 0))`
623			`dn_fib_flush();`
624			`}`
625			`}`
626			`}`
627
628			`static void dn_fib_disable_addr(struct net_device *dev, int force)`
629			`{`
630			`if (dn_fib_sync_down(0, dev, force))`
631			`dn_fib_flush();`
632			`dn_rt_cache_flush(0);`
633			`neigh_ifdown(&dn_neigh_table, dev);`
634			`}`
635
636			`static int dn_fib_dnaddr_event(struct notifier_block this, unsigned long event, void ptr)`
637			`{`
638			`struct dn_ifaddr ifa = (struct dn_ifaddr )ptr;`
639
640			`switch(event) {`
641			`case NETDEV_UP:`
642			`dn_fib_add_ifaddr(ifa);`
643			`dn_fib_sync_up(ifa->ifa_dev->dev);`
644			`dn_rt_cache_flush(-1);`
645			`break;`
646			`case NETDEV_DOWN:`
647			`dn_fib_del_ifaddr(ifa);`
648			`if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) {`
649			`dn_fib_disable_addr(ifa->ifa_dev->dev, 1);`
650			`} else {`
651			`dn_rt_cache_flush(-1);`
652			`}`
653			`break;`
654			`}`
655			`return NOTIFY_DONE;`
656			`}`
657
658			`static int dn_fib_sync_down(__le16 local, struct net_device *dev, int force)`
659			`{`
660			`int ret = 0;`
661			`int scope = RT_SCOPE_NOWHERE;`
662
663			`if (force)`
664			`scope = -1;`
665
666			`for_fib_info() {`
667			`/*`
668			`* This makes no sense for DECnet.... we will almost`
669			`* certainly have more than one local address the same`
670			`* over all our interfaces. It needs thinking about`
671			`* some more.`
672			`*/`
673			`if (local && fi->fib_prefsrc == local) {`
674			`fi->fib_flags \|= RTNH_F_DEAD;`
675			`ret++;`
676			`} else if (dev && fi->fib_nhs) {`
677			`int dead = 0;`
678
679			`change_nexthops(fi) {`
680			`if (nh->nh_flags&RTNH_F_DEAD)`
681			`dead++;`
682			`else if (nh->nh_dev == dev &&`
683			`nh->nh_scope != scope) {`
684			`spin_lock_bh(&dn_fib_multipath_lock);`
685			`nh->nh_flags \|= RTNH_F_DEAD;`
686			`fi->fib_power -= nh->nh_power;`
687			`nh->nh_power = 0;`
688			`spin_unlock_bh(&dn_fib_multipath_lock);`
689			`dead++;`
690			`}`
691			`} endfor_nexthops(fi)`
692			`if (dead == fi->fib_nhs) {`
693			`fi->fib_flags \|= RTNH_F_DEAD;`
694			`ret++;`
695			`}`
696			`}`
697			`} endfor_fib_info();`
698			`return ret;`
699			`}`
700
701
702			`static int dn_fib_sync_up(struct net_device *dev)`
703			`{`
704			`int ret = 0;`
705
706			`if (!(dev->flags&IFF_UP))`
707			`return 0;`
708
709			`for_fib_info() {`
710			`int alive = 0;`
711
712			`change_nexthops(fi) {`
713			`if (!(nh->nh_flags&RTNH_F_DEAD)) {`
714			`alive++;`
715			`continue;`
716			`}`
717			`if (nh->nh_dev == NULL \|\| !(nh->nh_dev->flags&IFF_UP))`
718			`continue;`
719			`if (nh->nh_dev != dev \|\| dev->dn_ptr == NULL)`
720			`continue;`
721			`alive++;`
722			`spin_lock_bh(&dn_fib_multipath_lock);`
723			`nh->nh_power = 0;`
724			`nh->nh_flags &= ~RTNH_F_DEAD;`
725			`spin_unlock_bh(&dn_fib_multipath_lock);`
726			`} endfor_nexthops(fi);`
727
728			`if (alive > 0) {`
729			`fi->fib_flags &= ~RTNH_F_DEAD;`
730			`ret++;`
731			`}`
732			`} endfor_fib_info();`
733			`return ret;`
734			`}`
735
736			`static struct notifier_block dn_fib_dnaddr_notifier = {`
737			`.notifier_call = dn_fib_dnaddr_event,`
738			`};`
739
740			`void __exit dn_fib_cleanup(void)`
741			`{`
742			`dn_fib_table_cleanup();`
743			`dn_fib_rules_cleanup();`
744
745			`unregister_dnaddr_notifier(&dn_fib_dnaddr_notifier);`
746			`}`
747
748
749			`void __init dn_fib_init(void)`
750			`{`
751			`dn_fib_table_init();`
752			`dn_fib_rules_init();`
753
754			`register_dnaddr_notifier(&dn_fib_dnaddr_notifier);`
755
756			`rtnl_register(PF_DECnet, RTM_NEWROUTE, dn_fib_rtm_newroute, NULL);`
757			`rtnl_register(PF_DECnet, RTM_DELROUTE, dn_fib_rtm_delroute, NULL);`
758			`}`
759
760