/*
 *      Linux INET6 implementation
 *      FIB front-end.
 *
 *      Authors:
 *      Pedro Roque             <roque@di.fc.ul.pt>
 *
 *      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.
 */

/*      Changes:
 *
 *      YOSHIFUJI Hideaki @USAGI
 *              reworked default router selection.
 *              - respect outgoing interface
 *              - select from (probably) reachable routers (i.e.
 *              routers in REACHABLE, STALE, DELAY or PROBE states).
 *              - always select the same router if it is (probably)
 *              reachable.  otherwise, round-robin the list.
 *      Ville Nuorvala
 *              Fixed routing subtrees.
 */

#define pr_fmt(fmt) "IPv6: " fmt

#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/times.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/route.h>
#include <linux/netdevice.h>
#include <linux/in6.h>
#include <linux/mroute6.h>
#include <linux/init.h>
#include <linux/if_arp.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/nsproxy.h>
#include <linux/slab.h>
#include <net/net_namespace.h>
#include <net/snmp.h>
#include <net/ipv6.h>
#include <net/ip6_fib.h>
#include <net/ip6_route.h>
#include <net/ndisc.h>
#include <net/addrconf.h>
#include <net/tcp.h>
#include <linux/rtnetlink.h>
#include <net/dst.h>
#include <net/dst_metadata.h>
#include <net/xfrm.h>
#include <net/netevent.h>
#include <net/netlink.h>
#include <net/nexthop.h>
#include <net/lwtunnel.h>
#ifndef __GENKSYMS__
#include <net/ip_tunnels.h>
#endif

#include <asm/uaccess.h>

#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif

enum rt6_nud_state {
        RT6_NUD_FAIL_HARD = -3,
        RT6_NUD_FAIL_PROBE = -2,
        RT6_NUD_FAIL_DO_RR = -1,
        RT6_NUD_SUCCEED = 1
};

static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort);
static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
static unsigned int      ip6_default_advmss(const struct dst_entry *dst);
static unsigned int      ip6_mtu(const struct dst_entry *dst);
static struct dst_entry *ip6_negative_advice(struct dst_entry *);
static void             ip6_dst_destroy(struct dst_entry *);
static void             ip6_dst_ifdown(struct dst_entry *,
                                       struct net_device *dev, int how);
static int               ip6_dst_gc(struct dst_ops *ops);

static int              ip6_pkt_discard(struct sk_buff *skb);
static int              ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb);
static int              ip6_pkt_prohibit(struct sk_buff *skb);
static int              ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb);
static void             ip6_link_failure(struct sk_buff *skb);
static void             ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
                                           struct sk_buff *skb, u32 mtu);
static void             rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
                                        struct sk_buff *skb);
static void             rt6_dst_from_metrics_check(struct rt6_info *rt);
static int rt6_score_route(struct rt6_info *rt, int oif, int strict);

#ifdef CONFIG_IPV6_ROUTE_INFO
static struct rt6_info *rt6_add_route_info(struct net *net,
                                           const struct in6_addr *prefix, int prefixlen,
                                           const struct in6_addr *gwaddr, int ifindex,
                                           unsigned int pref);
static struct rt6_info *rt6_get_route_info(struct net *net,
                                           const struct in6_addr *prefix, int prefixlen,
                                           const struct in6_addr *gwaddr, int ifindex);
#endif

struct uncached_list {
        spinlock_t              lock;
        struct list_head        head;
};

static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);

static void rt6_uncached_list_add(struct rt6_info *rt)
{
        struct uncached_list *ul = __this_cpu_ptr(&rt6_uncached_list);

        rt->dst.flags |= DST_NOCACHE;
        rt->rt6i_uncached_list = ul;

        spin_lock_bh(&ul->lock);
        list_add_tail(&rt->rt6i_uncached, &ul->head);
        spin_unlock_bh(&ul->lock);
}

static void rt6_uncached_list_del(struct rt6_info *rt)
{
        if (!list_empty(&rt->rt6i_uncached)) {
                struct uncached_list *ul = rt->rt6i_uncached_list;

                spin_lock_bh(&ul->lock);
                list_del(&rt->rt6i_uncached);
                spin_unlock_bh(&ul->lock);
        }
}

static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
{
        struct net_device *loopback_dev = net->loopback_dev;
        int cpu;

        if (dev == loopback_dev)
                return;

        for_each_possible_cpu(cpu) {
                struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
                struct rt6_info *rt;

                spin_lock_bh(&ul->lock);
                list_for_each_entry(rt, &ul->head, rt6i_uncached) {
                        struct inet6_dev *rt_idev = rt->rt6i_idev;
                        struct net_device *rt_dev = rt->dst.dev;

                        if (rt_idev->dev == dev) {
                                rt->rt6i_idev = in6_dev_get(loopback_dev);
                                in6_dev_put(rt_idev);
                        }

                        if (rt_dev == dev) {
                                rt->dst.dev = loopback_dev;
                                dev_hold(rt->dst.dev);
                                dev_put(rt_dev);
                        }
                }
                spin_unlock_bh(&ul->lock);
        }
}

static u32 *rt6_pcpu_cow_metrics(struct rt6_info *rt)
{
        return dst_metrics_write_ptr(rt->dst.from);
}

static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
{
        struct rt6_info *rt = (struct rt6_info *)dst;

        if (rt->rt6i_flags & RTF_PCPU)
                return rt6_pcpu_cow_metrics(rt);
        else if (rt->rt6i_flags & RTF_CACHE)
                return NULL;
        else
                return dst_cow_metrics_generic(dst, old);
}

static inline const void *choose_neigh_daddr(struct rt6_info *rt,
                                             struct sk_buff *skb,
                                             const void *daddr)
{
        struct in6_addr *p = &rt->rt6i_gateway;

        if (!ipv6_addr_any(p))
                return (const void *) p;
        else if (skb)
                return &ipv6_hdr(skb)->daddr;
        return daddr;
}

static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
                                          struct sk_buff *skb,
                                          const void *daddr)
{
        struct rt6_info *rt = (struct rt6_info *) dst;
        struct neighbour *n;

        daddr = choose_neigh_daddr(rt, skb, daddr);
        n = __ipv6_neigh_lookup(dst->dev, daddr);
        if (n)
                return n;
        return neigh_create(&nd_tbl, daddr, dst->dev);
}

static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
{
        struct net_device *dev = dst->dev;
        struct rt6_info *rt = (struct rt6_info *)dst;

        daddr = choose_neigh_daddr(rt, NULL, daddr);
        if (!daddr)
                return;
        if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
                return;
        if (ipv6_addr_is_multicast((const struct in6_addr *)daddr))
                return;
        __ipv6_confirm_neigh(dev, daddr);
}

static struct dst_ops ip6_dst_ops_template = {
        .family                 =       AF_INET6,
        .protocol               =       cpu_to_be16(ETH_P_IPV6),
        .gc                     =       ip6_dst_gc,
        .gc_thresh              =       1024,
        .check                  =       ip6_dst_check,
        .default_advmss         =       ip6_default_advmss,
        .mtu                    =       ip6_mtu,
        .cow_metrics            =       ipv6_cow_metrics,
        .destroy                =       ip6_dst_destroy,
        .ifdown                 =       ip6_dst_ifdown,
        .negative_advice        =       ip6_negative_advice,
        .link_failure           =       ip6_link_failure,
        .update_pmtu            =       ip6_rt_update_pmtu,
        .redirect               =       rt6_do_redirect,
        .local_out              =       __ip6_local_out,
        .neigh_lookup           =       ip6_neigh_lookup,
        .confirm_neigh          =       ip6_confirm_neigh,
};

static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
{
        unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

        return mtu ? : dst->dev->mtu;
}

static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
                                         struct sk_buff *skb, u32 mtu)
{
}

static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
                                      struct sk_buff *skb)
{
}

static struct dst_ops ip6_dst_blackhole_ops = {
        .family                 =       AF_INET6,
        .protocol               =       cpu_to_be16(ETH_P_IPV6),
        .destroy                =       ip6_dst_destroy,
        .check                  =       ip6_dst_check,
        .mtu                    =       ip6_blackhole_mtu,
        .default_advmss         =       ip6_default_advmss,
        .update_pmtu            =       ip6_rt_blackhole_update_pmtu,
        .redirect               =       ip6_rt_blackhole_redirect,
        .cow_metrics            =       dst_cow_metrics_generic,
        .neigh_lookup           =       ip6_neigh_lookup,
};

static const u32 ip6_template_metrics[RTAX_MAX] = {
        [RTAX_HOPLIMIT - 1] = 0,
};

static const struct rt6_info ip6_null_entry_template = {
        .dst = {
                .__refcnt       = ATOMIC_INIT(1),
                .__use          = 1,
                .obsolete       = DST_OBSOLETE_FORCE_CHK,
                .error          = -ENETUNREACH,
                .input          = ip6_pkt_discard,
                .output         = ip6_pkt_discard_out,
        },
        .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
        .rt6i_protocol  = RTPROT_KERNEL,
        .rt6i_metric    = ~(u32) 0,
        .rt6i_ref       = ATOMIC_INIT(1),
};

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

static const struct rt6_info ip6_prohibit_entry_template = {
        .dst = {
                .__refcnt       = ATOMIC_INIT(1),
                .__use          = 1,
                .obsolete       = DST_OBSOLETE_FORCE_CHK,
                .error          = -EACCES,
                .input          = ip6_pkt_prohibit,
                .output         = ip6_pkt_prohibit_out,
        },
        .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
        .rt6i_protocol  = RTPROT_KERNEL,
        .rt6i_metric    = ~(u32) 0,
        .rt6i_ref       = ATOMIC_INIT(1),
};

static const struct rt6_info ip6_blk_hole_entry_template = {
        .dst = {
                .__refcnt       = ATOMIC_INIT(1),
                .__use          = 1,
                .obsolete       = DST_OBSOLETE_FORCE_CHK,
                .error          = -EINVAL,
                .input          = dst_discard,
                .output         = dst_discard_sk,
        },
        .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
        .rt6i_protocol  = RTPROT_KERNEL,
        .rt6i_metric    = ~(u32) 0,
        .rt6i_ref       = ATOMIC_INIT(1),
};

#endif

static void rt6_info_init(struct rt6_info *rt)
{
        struct dst_entry *dst = &rt->dst;

        memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
        INIT_LIST_HEAD(&rt->rt6i_siblings);
        INIT_LIST_HEAD(&rt->rt6i_uncached);
}

/* allocate dst with ip6_dst_ops */
static struct rt6_info *__ip6_dst_alloc(struct net *net,
                                        struct net_device *dev,
                                        int flags)
{
        struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
                                        0, DST_OBSOLETE_FORCE_CHK, flags);

        if (rt)
                rt6_info_init(rt);

        return rt;
}

static struct rt6_info *ip6_dst_alloc(struct net *net,
                                      struct net_device *dev,
                                      int flags)
{
        struct rt6_info *rt = __ip6_dst_alloc(net, dev, flags);

        if (rt) {
                rt->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_ATOMIC);
                if (rt->rt6i_pcpu) {
                        int cpu;

                        for_each_possible_cpu(cpu) {
                                struct rt6_info **p;

                                p = per_cpu_ptr(rt->rt6i_pcpu, cpu);
                                /* no one shares rt */
                                *p =  NULL;
                        }
                } else {
                        dst_destroy((struct dst_entry *)rt);
                        return NULL;
                }
        }

        return rt;
}

static void ip6_dst_destroy(struct dst_entry *dst)
{
        struct rt6_info *rt = (struct rt6_info *)dst;
        struct dst_entry *from = dst->from;
        struct inet6_dev *idev;

        dst_destroy_metrics_generic(dst);

        if (rt->rt6i_pcpu)
                free_percpu(rt->rt6i_pcpu);

        rt6_uncached_list_del(rt);

        idev = rt->rt6i_idev;
        if (idev) {
                rt->rt6i_idev = NULL;
                in6_dev_put(idev);
        }

        dst->from = NULL;
        dst_release(from);
}

static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
                           int how)
{
        struct rt6_info *rt = (struct rt6_info *)dst;
        struct inet6_dev *idev = rt->rt6i_idev;
        struct net_device *loopback_dev =
                dev_net(dev)->loopback_dev;

        if (dev != loopback_dev) {
                if (idev && idev->dev == dev) {
                        struct inet6_dev *loopback_idev =
                                in6_dev_get(loopback_dev);
                        if (loopback_idev) {
                                rt->rt6i_idev = loopback_idev;
                                in6_dev_put(idev);
                        }
                }
        }
}

static bool __rt6_check_expired(const struct rt6_info *rt)
{
        if (rt->rt6i_flags & RTF_EXPIRES)
                return time_after(jiffies, rt->dst.expires);
        else
                return false;
}

static bool rt6_check_expired(const struct rt6_info *rt)
{
        if (rt->rt6i_flags & RTF_EXPIRES) {
                if (time_after(jiffies, rt->dst.expires))
                        return true;
        } else if (rt->dst.from) {
                return rt6_check_expired((struct rt6_info *) rt->dst.from);
        }
        return false;
}

/* Multipath route selection:
 *   Hash based function using packet header and flowlabel.
 * Adapted from fib_info_hashfn()
 */
static int rt6_info_hash_nhsfn(unsigned int candidate_count,
                               const struct flowi6 *fl6)
{
        unsigned int val = fl6->flowi6_proto;

        val ^= ipv6_addr_hash(&fl6->daddr);
        val ^= ipv6_addr_hash(&fl6->saddr);

        /* Work only if this not encapsulated */
        switch (fl6->flowi6_proto) {
        case IPPROTO_UDP:
        case IPPROTO_TCP:
        case IPPROTO_SCTP:
                val ^= (__force u16)fl6->fl6_sport;
                val ^= (__force u16)fl6->fl6_dport;
                break;

        case IPPROTO_ICMPV6:
                val ^= (__force u16)fl6->fl6_icmp_type;
                val ^= (__force u16)fl6->fl6_icmp_code;
                break;
        }
        /* RFC6438 recommands to use flowlabel */
        val ^= (__force u32)fl6->flowlabel;

        /* Perhaps, we need to tune, this function? */
        val = val ^ (val >> 7) ^ (val >> 12);
        return val % candidate_count;
}

static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
                                             struct flowi6 *fl6, int oif,
                                             int strict)
{
        struct rt6_info *sibling, *next_sibling;
        int route_choosen;

        route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
        /* Don't change the route, if route_choosen == 0
         * (siblings does not include ourself)
         */
        if (route_choosen)
                list_for_each_entry_safe(sibling, next_sibling,
                                &match->rt6i_siblings, rt6i_siblings) {
                        route_choosen--;
                        if (route_choosen == 0) {
                                if (rt6_score_route(sibling, oif, strict) < 0)
                                        break;
                                match = sibling;
                                break;
                        }
                }
        return match;
}

/*
 *      Route lookup. Any table->tb6_lock is implied.
 */

static inline struct rt6_info *rt6_device_match(struct net *net,
                                                    struct rt6_info *rt,
                                                    const struct in6_addr *saddr,
                                                    int oif,
                                                    int flags)
{
        struct rt6_info *local = NULL;
        struct rt6_info *sprt;

        if (!oif && ipv6_addr_any(saddr))
                goto out;

        for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
                struct net_device *dev = sprt->dst.dev;

                if (oif) {
                        if (dev->ifindex == oif)
                                return sprt;
                        if (dev->flags & IFF_LOOPBACK) {
                                if (!sprt->rt6i_idev ||
                                    sprt->rt6i_idev->dev->ifindex != oif) {
                                        if (flags & RT6_LOOKUP_F_IFACE && oif)
                                                continue;
                                        if (local && (!oif ||
                                                      local->rt6i_idev->dev->ifindex == oif))
                                                continue;
                                }
                                local = sprt;
                        }
                } else {
                        if (ipv6_chk_addr(net, saddr, dev,
                                          flags & RT6_LOOKUP_F_IFACE))
                                return sprt;
                }
        }

        if (oif) {
                if (local)
                        return local;

                if (flags & RT6_LOOKUP_F_IFACE)
                        return net->ipv6.ip6_null_entry;
        }
out:
        return rt;
}

#ifdef CONFIG_IPV6_ROUTER_PREF
struct __rt6_probe_work {
        struct work_struct work;
        struct in6_addr target;
        struct net_device *dev;
};

static void rt6_probe_deferred(struct work_struct *w)
{
        struct in6_addr mcaddr;
        struct __rt6_probe_work *work =
                container_of(w, struct __rt6_probe_work, work);

        addrconf_addr_solict_mult(&work->target, &mcaddr);
        ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
        dev_put(work->dev);
        kfree(w);
}

static void rt6_probe(struct rt6_info *rt)
{
        struct neighbour *neigh;
        /*
         * Okay, this does not seem to be appropriate
         * for now, however, we need to check if it
         * is really so; aka Router Reachability Probing.
         *
         * Router Reachability Probe MUST be rate-limited
         * to no more than one per minute.
         */
        if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
                return;
        rcu_read_lock_bh();
        neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
        if (neigh) {
                write_lock(&neigh->lock);
                if (neigh->nud_state & NUD_VALID)
                        goto out;
        }

        if (!neigh ||
            time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
                struct __rt6_probe_work *work;

                work = kmalloc(sizeof(*work), GFP_ATOMIC);

                if (neigh && work)
                        __neigh_set_probe_once(neigh);

                if (neigh)
                        write_unlock(&neigh->lock);

                if (work) {
                        INIT_WORK(&work->work, rt6_probe_deferred);
                        work->target = rt->rt6i_gateway;
                        dev_hold(rt->dst.dev);
                        work->dev = rt->dst.dev;
                        schedule_work(&work->work);
                }
        } else {
out:
                write_unlock(&neigh->lock);
        }
        rcu_read_unlock_bh();
}
#else
static inline void rt6_probe(struct rt6_info *rt)
{
}
#endif

/*
 * Default Router Selection (RFC 2461 6.3.6)
 */
static inline int rt6_check_dev(struct rt6_info *rt, int oif)
{
        struct net_device *dev = rt->dst.dev;
        if (!oif || dev->ifindex == oif)
                return 2;
        if ((dev->flags & IFF_LOOPBACK) &&
            rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
                return 1;
        return 0;
}

static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
{
        struct neighbour *neigh;
        enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;

        if (rt->rt6i_flags & RTF_NONEXTHOP ||
            !(rt->rt6i_flags & RTF_GATEWAY))
                return RT6_NUD_SUCCEED;

        rcu_read_lock_bh();
        neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
        if (neigh) {
                read_lock(&neigh->lock);
                if (neigh->nud_state & NUD_VALID)
                        ret = RT6_NUD_SUCCEED;
#ifdef CONFIG_IPV6_ROUTER_PREF
                else if (!(neigh->nud_state & NUD_FAILED))
                        ret = RT6_NUD_SUCCEED;
                else
                        ret = RT6_NUD_FAIL_PROBE;
#endif
                read_unlock(&neigh->lock);
        } else {
                ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
                      RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
        }
        rcu_read_unlock_bh();

        return ret;
}

static int rt6_score_route(struct rt6_info *rt, int oif,
                           int strict)
{
        int m;

        m = rt6_check_dev(rt, oif);
        if (!m && (strict & RT6_LOOKUP_F_IFACE))
                return RT6_NUD_FAIL_HARD;
#ifdef CONFIG_IPV6_ROUTER_PREF
        m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
#endif
        if (strict & RT6_LOOKUP_F_REACHABLE) {
                int n = rt6_check_neigh(rt);
                if (n < 0)
                        return n;
        }
        return m;
}

static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
                                   int *mpri, struct rt6_info *match,
                                   bool *do_rr)
{
        int m;
        bool match_do_rr = false;

        if (rt6_check_expired(rt))
                goto out;

        m = rt6_score_route(rt, oif, strict);
        if (m == RT6_NUD_FAIL_DO_RR) {
                match_do_rr = true;
                m = 0; /* lowest valid score */
        } else if (m == RT6_NUD_FAIL_HARD) {
                goto out;
        }

        if (strict & RT6_LOOKUP_F_REACHABLE)
                rt6_probe(rt);

        /* note that m can be RT6_NUD_FAIL_PROBE at this point */
        if (m > *mpri) {
                *do_rr = match_do_rr;
                *mpri = m;
                match = rt;
        }
out:
        return match;
}

static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
                                     struct rt6_info *rr_head,
                                     u32 metric, int oif, int strict,
                                     bool *do_rr)
{
        struct rt6_info *rt, *match, *cont;
        int mpri = -1;

        match = NULL;
        cont = NULL;
        for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
                if (rt->rt6i_metric != metric) {
                        cont = rt;
                        break;
                }

                match = find_match(rt, oif, strict, &mpri, match, do_rr);
        }

        for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
                if (rt->rt6i_metric != metric) {
                        cont = rt;
                        break;
                }

                match = find_match(rt, oif, strict, &mpri, match, do_rr);
        }

        if (match || !cont)
                return match;

        for (rt = cont; rt; rt = rt->dst.rt6_next)
                match = find_match(rt, oif, strict, &mpri, match, do_rr);

        return match;
}

static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
{
        struct rt6_info *match, *rt0;
        struct net *net;
        bool do_rr = false;

        rt0 = fn->rr_ptr;
        if (!rt0)
                fn->rr_ptr = rt0 = fn->leaf;

        match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
                             &do_rr);

        if (do_rr) {
                struct rt6_info *next = rt0->dst.rt6_next;

                /* no entries matched; do round-robin */
                if (!next || next->rt6i_metric != rt0->rt6i_metric)
                        next = fn->leaf;

                if (next != rt0)
                        fn->rr_ptr = next;
        }

        net = dev_net(rt0->dst.dev);
        return match ? match : net->ipv6.ip6_null_entry;
}

static bool rt6_is_gw_or_nonexthop(const struct rt6_info *rt)
{
        return (rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
}

#ifdef CONFIG_IPV6_ROUTE_INFO
int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
                  const struct in6_addr *gwaddr)
{
        struct net *net = dev_net(dev);
        struct route_info *rinfo = (struct route_info *) opt;
        struct in6_addr prefix_buf, *prefix;
        unsigned int pref;
        unsigned long lifetime;
        struct rt6_info *rt;

        if (len < sizeof(struct route_info)) {
                return -EINVAL;
        }

        /* Sanity check for prefix_len and length */
        if (rinfo->length > 3) {
                return -EINVAL;
        } else if (rinfo->prefix_len > 128) {
                return -EINVAL;
        } else if (rinfo->prefix_len > 64) {
                if (rinfo->length < 2) {
                        return -EINVAL;
                }
        } else if (rinfo->prefix_len > 0) {
                if (rinfo->length < 1) {
                        return -EINVAL;
                }
        }

        pref = rinfo->route_pref;
        if (pref == ICMPV6_ROUTER_PREF_INVALID)
                return -EINVAL;

        lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);

        if (rinfo->length == 3)
                prefix = (struct in6_addr *)rinfo->prefix;
        else {
                /* this function is safe */
                ipv6_addr_prefix(&prefix_buf,
                                 (struct in6_addr *)rinfo->prefix,
                                 rinfo->prefix_len);
                prefix = &prefix_buf;
        }

        if (rinfo->prefix_len == 0)
                rt = rt6_get_dflt_router(gwaddr, dev);
        else
                rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
                                        gwaddr, dev->ifindex);

        if (rt && !lifetime) {
                ip6_del_rt(rt);
                rt = NULL;
        }

        if (!rt && lifetime)
                rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
                                        pref);
        else if (rt)
                rt->rt6i_flags = RTF_ROUTEINFO |
                                 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);

        if (rt) {
                if (!addrconf_finite_timeout(lifetime))
                        rt6_clean_expires(rt);
                else
                        rt6_set_expires(rt, jiffies + HZ * lifetime);

                ip6_rt_put(rt);
        }
        return 0;
}
#endif

static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
                                        struct in6_addr *saddr)
{
        struct fib6_node *pn;
        while (1) {
                if (fn->fn_flags & RTN_TL_ROOT)
                        return NULL;
                pn = fn->parent;
                if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
                        fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
                else
                        fn = pn;
                if (fn->fn_flags & RTN_RTINFO)
                        return fn;
        }
}

static struct rt6_info *ip6_pol_route_lookup(struct net *net,
                                             struct fib6_table *table,
                                             struct flowi6 *fl6, int flags)
{
        struct fib6_node *fn;
        struct rt6_info *rt;

        read_lock_bh(&table->tb6_lock);
        fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
restart:
        rt = fn->leaf;
        rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
        if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
                rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
        if (rt == net->ipv6.ip6_null_entry) {
                fn = fib6_backtrack(fn, &fl6->saddr);
                if (fn)
                        goto restart;
        }
        dst_use(&rt->dst, jiffies);
        read_unlock_bh(&table->tb6_lock);
        return rt;

}

struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
                                    int flags)
{
        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
}
EXPORT_SYMBOL_GPL(ip6_route_lookup);

struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
                            const struct in6_addr *saddr, int oif, int strict)
{
        struct flowi6 fl6 = {
                .flowi6_oif = oif,
                .daddr = *daddr,
        };
        struct dst_entry *dst;
        int flags = strict ? RT6_LOOKUP_F_IFACE : 0;

        if (saddr) {
                memcpy(&fl6.saddr, saddr, sizeof(*saddr));
                flags |= RT6_LOOKUP_F_HAS_SADDR;
        }

        dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
        if (dst->error == 0)
                return (struct rt6_info *) dst;

        dst_release(dst);

        return NULL;
}

EXPORT_SYMBOL(rt6_lookup);

/* ip6_ins_rt is called with FREE table->tb6_lock.
   It takes new route entry, the addition fails by any reason the
   route is freed. In any case, if caller does not hold it, it may
   be destroyed.
 */

static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
                        struct mx6_config *mxc)
{
        int err;
        struct fib6_table *table;

        table = rt->rt6i_table;
        write_lock_bh(&table->tb6_lock);
        err = fib6_add(&table->tb6_root, rt, info, mxc);
        write_unlock_bh(&table->tb6_lock);

        return err;
}

int ip6_ins_rt(struct rt6_info *rt)
{
        struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
        struct mx6_config mxc = { .mx = NULL, };

        return __ip6_ins_rt(rt, &info, &mxc);
}

static struct rt6_info *ip6_rt_cache_alloc(struct rt6_info *ort,
                                           const struct in6_addr *daddr,
                                           const struct in6_addr *saddr)
{
        struct rt6_info *rt;

        /*
         *      Clone the route.
         */

        if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))
                ort = (struct rt6_info *)ort->dst.from;

        rt = __ip6_dst_alloc(dev_net(ort->dst.dev), ort->dst.dev, 0);

        if (!rt)
                return NULL;

        ip6_rt_copy_init(rt, ort);
        rt->rt6i_flags |= RTF_CACHE;
        rt->rt6i_metric = 0;
        rt->dst.flags |= DST_HOST;
        rt->rt6i_dst.addr = *daddr;
        rt->rt6i_dst.plen = 128;

        if (!rt6_is_gw_or_nonexthop(ort)) {
                if (ort->rt6i_dst.plen != 128 &&
                    ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))

                        rt->rt6i_flags |= RTF_ANYCAST;
#ifdef CONFIG_IPV6_SUBTREES
                if (rt->rt6i_src.plen && saddr) {
                        rt->rt6i_src.addr = *saddr;
                        rt->rt6i_src.plen = 128;
                }
#endif
        }

        return rt;
}

static struct rt6_info *ip6_rt_pcpu_alloc(struct rt6_info *rt)
{
        struct rt6_info *pcpu_rt;

        pcpu_rt = __ip6_dst_alloc(dev_net(rt->dst.dev),
                                  rt->dst.dev, rt->dst.flags);

        if (!pcpu_rt)
                return NULL;
        ip6_rt_copy_init(pcpu_rt, rt);
        pcpu_rt->rt6i_protocol = rt->rt6i_protocol;
        pcpu_rt->rt6i_flags |= RTF_PCPU;
        return pcpu_rt;
}

/* It should be called with read_lock_bh(&tb6_lock) acquired */
static struct rt6_info *rt6_get_pcpu_route(struct rt6_info *rt)
{
        struct rt6_info *pcpu_rt, **p;

        p = this_cpu_ptr(rt->rt6i_pcpu);
        pcpu_rt = *p;

        if (pcpu_rt) {
                dst_hold(&pcpu_rt->dst);
                rt6_dst_from_metrics_check(pcpu_rt);
        }
        return pcpu_rt;
}

static struct rt6_info *rt6_make_pcpu_route(struct rt6_info *rt)
{
        struct fib6_table *table = rt->rt6i_table;
        struct rt6_info *pcpu_rt, *prev, **p;

        pcpu_rt = ip6_rt_pcpu_alloc(rt);
        if (!pcpu_rt) {
                struct net *net = dev_net(rt->dst.dev);

                dst_hold(&net->ipv6.ip6_null_entry->dst);
                return net->ipv6.ip6_null_entry;
        }

        read_lock_bh(&table->tb6_lock);
        if (rt->rt6i_pcpu) {
                p = this_cpu_ptr(rt->rt6i_pcpu);
                prev = cmpxchg(p, NULL, pcpu_rt);
                if (prev) {
                        /* If someone did it before us, return prev instead */
                        dst_destroy(&pcpu_rt->dst);
                        pcpu_rt = prev;
                }
        } else {
                /* rt has been removed from the fib6 tree
                 * before we have a chance to acquire the read_lock.
                 * In this case, don't brother to create a pcpu rt
                 * since rt is going away anyway.  The next
                 * dst_check() will trigger a re-lookup.
                 */
                dst_destroy(&pcpu_rt->dst);
                pcpu_rt = rt;
        }
        dst_hold(&pcpu_rt->dst);
        rt6_dst_from_metrics_check(pcpu_rt);
        read_unlock_bh(&table->tb6_lock);
        return pcpu_rt;
}

static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
                                      struct flowi6 *fl6, int flags)
{
        struct fib6_node *fn, *saved_fn;
        struct rt6_info *rt;
        int strict = 0;

        strict |= flags & RT6_LOOKUP_F_IFACE;
        if (net->ipv6.devconf_all->forwarding == 0)
                strict |= RT6_LOOKUP_F_REACHABLE;

        read_lock_bh(&table->tb6_lock);

        fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
        saved_fn = fn;

redo_rt6_select:
        rt = rt6_select(fn, oif, strict);
        if (rt->rt6i_nsiblings)
                rt = rt6_multipath_select(rt, fl6, oif, strict);
        if (rt == net->ipv6.ip6_null_entry) {
                fn = fib6_backtrack(fn, &fl6->saddr);
                if (fn)
                        goto redo_rt6_select;
                else if (strict & RT6_LOOKUP_F_REACHABLE) {
                        /* also consider unreachable route */
                        strict &= ~RT6_LOOKUP_F_REACHABLE;
                        fn = saved_fn;
                        goto redo_rt6_select;
                }
        }


        if (rt == net->ipv6.ip6_null_entry || (rt->rt6i_flags & RTF_CACHE)) {
                dst_use(&rt->dst, jiffies);
                read_unlock_bh(&table->tb6_lock);

                rt6_dst_from_metrics_check(rt);
                return rt;
        } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
                            !(rt->rt6i_flags & RTF_GATEWAY))) {
                /* Create a RTF_CACHE clone which will not be
                 * owned by the fib6 tree.  It is for the special case where
                 * the daddr in the skb during the neighbor look-up is different
                 * from the fl6->daddr used to look-up route here.
                 */

                struct rt6_info *uncached_rt;

                dst_use(&rt->dst, jiffies);
                read_unlock_bh(&table->tb6_lock);

                uncached_rt = ip6_rt_cache_alloc(rt, &fl6->daddr, NULL);
                dst_release(&rt->dst);

                if (uncached_rt)
                        rt6_uncached_list_add(uncached_rt);
                else
                        uncached_rt = net->ipv6.ip6_null_entry;

                dst_hold(&uncached_rt->dst);
                return uncached_rt;

        } else {
                /* Get a percpu copy */

                struct rt6_info *pcpu_rt;

                rt->dst.lastuse = jiffies;
                rt->dst.__use++;
                pcpu_rt = rt6_get_pcpu_route(rt);

                if (pcpu_rt) {
                        read_unlock_bh(&table->tb6_lock);
                } else {
                        /* We have to do the read_unlock first
                         * because rt6_make_pcpu_route() may trigger
                         * ip6_dst_gc() which will take the write_lock.
                         */
                        dst_hold(&rt->dst);
                        read_unlock_bh(&table->tb6_lock);
                        pcpu_rt = rt6_make_pcpu_route(rt);
                        dst_release(&rt->dst);
                }

                return pcpu_rt;

        }
}

static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
                                            struct flowi6 *fl6, int flags)
{
        return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
}

static struct dst_entry *ip6_route_input_lookup(struct net *net,
                                                struct net_device *dev,
                                                struct flowi6 *fl6, int flags)
{
        if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
                flags |= RT6_LOOKUP_F_IFACE;

        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
}

void ip6_route_input(struct sk_buff *skb)
{
        const struct ipv6hdr *iph = ipv6_hdr(skb);
        struct net *net = dev_net(skb->dev);
        int flags = RT6_LOOKUP_F_HAS_SADDR;
        struct ip_tunnel_info *tun_info;
        struct flowi6 fl6 = {
                .flowi6_iif = skb->dev->ifindex,
                .daddr = iph->daddr,
                .saddr = iph->saddr,
                .flowlabel = ip6_flowinfo(iph),
                .flowi6_mark = skb->mark,
                .flowi6_proto = iph->nexthdr,
        };

        tun_info = skb_tunnel_info(skb);
        if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
                flowi6_tun_id_set(&fl6, tun_info->key.tun_id);
        skb_dst_drop(skb);
        skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
}

static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
                                             struct flowi6 *fl6, int flags)
{
        return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
}

struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
                                    struct flowi6 *fl6)
{
        int flags = 0;
        bool any_src;

        fl6->flowi6_iif = LOOPBACK_IFINDEX;

        any_src = ipv6_addr_any(&fl6->saddr);
        if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
            (fl6->flowi6_oif && any_src))
                flags |= RT6_LOOKUP_F_IFACE;

        if (!any_src)
                flags |= RT6_LOOKUP_F_HAS_SADDR;
        else if (sk)
                flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);

        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
}

EXPORT_SYMBOL(ip6_route_output);

struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
{
        struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
        struct dst_entry *new = NULL;

        rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
        if (rt) {
                rt6_info_init(rt);

                new = &rt->dst;
                new->__use = 1;
                new->input = dst_discard;
                new->output = dst_discard_sk;

                dst_copy_metrics(new, &ort->dst);
                rt->rt6i_idev = ort->rt6i_idev;
                if (rt->rt6i_idev)
                        in6_dev_hold(rt->rt6i_idev);

                rt->rt6i_gateway = ort->rt6i_gateway;
                rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
                rt->rt6i_metric = 0;

                memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
#ifdef CONFIG_IPV6_SUBTREES
                memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
#endif

                dst_free(new);
        }

        dst_release(dst_orig);
        return new ? new : ERR_PTR(-ENOMEM);
}

/*
 *      Destination cache support functions
 */

static void rt6_dst_from_metrics_check(struct rt6_info *rt)
{
        if (rt->dst.from &&
            dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
                dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
}

static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
{
        if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
                return NULL;

        if (rt6_check_expired(rt))
                return NULL;

        return &rt->dst;
}

static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt, u32 cookie)
{
        if (!__rt6_check_expired(rt) &&
            rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
            rt6_check((struct rt6_info *)(rt->dst.from), cookie))
                return &rt->dst;
        else
                return NULL;
}

static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
{
        struct rt6_info *rt;

        rt = (struct rt6_info *) dst;

        /* All IPV6 dsts are created with ->obsolete set to the value
         * DST_OBSOLETE_FORCE_CHK which forces validation calls down
         * into this function always.
         */

        rt6_dst_from_metrics_check(rt);

        if (rt->rt6i_flags & RTF_PCPU ||
            (unlikely(dst->flags & DST_NOCACHE) && rt->dst.from))
                return rt6_dst_from_check(rt, cookie);
        else
                return rt6_check(rt, cookie);
}

static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
{
        struct rt6_info *rt = (struct rt6_info *) dst;

        if (rt) {
                if (rt->rt6i_flags & RTF_CACHE) {
                        if (rt6_check_expired(rt)) {
                                ip6_del_rt(rt);
                                dst = NULL;
                        }
                } else {
                        dst_release(dst);
                        dst = NULL;
                }
        }
        return dst;
}

static void ip6_link_failure(struct sk_buff *skb)
{
        struct rt6_info *rt;

        icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

        rt = (struct rt6_info *) skb_dst(skb);
        if (rt) {
                if (rt->rt6i_flags & RTF_CACHE) {
                        dst_hold(&rt->dst);
                        ip6_del_rt(rt);
                } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
                        rt->rt6i_node->fn_sernum = -1;
                }
        }
}

static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
{
        struct net *net = dev_net(rt->dst.dev);

        rt->rt6i_flags |= RTF_MODIFIED;
        rt->rt6i_pmtu = mtu;
        rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
}

static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
{
        return !(rt->rt6i_flags & RTF_CACHE) &&
                (rt->rt6i_flags & RTF_PCPU || rt->rt6i_node);
}

static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
                                 const struct ipv6hdr *iph, u32 mtu)
{
        const struct in6_addr *daddr, *saddr;
        struct rt6_info *rt6 = (struct rt6_info *)dst;

        if (rt6->rt6i_flags & RTF_LOCAL)
                return;

        if (dst_metric_locked(dst, RTAX_MTU))
                return;

        if (iph) {
                daddr = &iph->daddr;
                saddr = &iph->saddr;
        } else if (sk) {
                daddr = &sk->sk_v6_daddr;
                saddr = &inet6_sk(sk)->saddr;
        } else {
                daddr = NULL;
                saddr = NULL;
        }
        dst_confirm_neigh(dst, daddr);
        mtu = max_t(u32, mtu, IPV6_MIN_MTU);
        if (mtu >= dst_mtu(dst))
                return;

        if (!rt6_cache_allowed_for_pmtu(rt6)) {
                rt6_do_update_pmtu(rt6, mtu);
        } else if (daddr) {
                struct rt6_info *nrt6;

                nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
                if (nrt6) {
                        rt6_do_update_pmtu(nrt6, mtu);

                        /* ip6_ins_rt(nrt6) will bump the
                         * rt6->rt6i_node->fn_sernum
                         * which will fail the next rt6_check() and
                         * invalidate the sk->sk_dst_cache.
                         */
                        ip6_ins_rt(nrt6);
                }
        }
}

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
                               struct sk_buff *skb, u32 mtu)
{
        __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
}

void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
                     int oif, u32 mark)
{
        const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
        struct dst_entry *dst;
        struct flowi6 fl6;

        memset(&fl6, 0, sizeof(fl6));
        fl6.flowi6_oif = oif;
        fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
        fl6.flowi6_flags = 0;
        fl6.daddr = iph->daddr;
        fl6.saddr = iph->saddr;
        fl6.flowlabel = ip6_flowinfo(iph);

        dst = ip6_route_output(net, NULL, &fl6);
        if (!dst->error)
                __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
        dst_release(dst);
}
EXPORT_SYMBOL_GPL(ip6_update_pmtu);

void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
{
        struct dst_entry *dst;

        ip6_update_pmtu(skb, sock_net(sk), mtu,
                        sk->sk_bound_dev_if, sk->sk_mark);

        dst = __sk_dst_get(sk);
        if (!dst || !dst->obsolete ||
            dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
                return;

        bh_lock_sock(sk);
        if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
                ip6_datagram_dst_update(sk, false);
        bh_unlock_sock(sk);
}
EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);

/* Handle redirects */
struct ip6rd_flowi {
        struct flowi6 fl6;
        struct in6_addr gateway;
};

static struct rt6_info *__ip6_route_redirect(struct net *net,
                                             struct fib6_table *table,
                                             struct flowi6 *fl6,
                                             int flags)
{
        struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
        struct rt6_info *rt;
        struct fib6_node *fn;

        /* Get the "current" route for this destination and
         * check if the redirect has come from approriate router.
         *
         * RFC 4861 specifies that redirects should only be
         * accepted if they come from the nexthop to the target.
         * Due to the way the routes are chosen, this notion
         * is a bit fuzzy and one might need to check all possible
         * routes.
         */

        read_lock_bh(&table->tb6_lock);
        fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
restart:
        for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
                if (rt6_check_expired(rt))
                        continue;
                if (rt->dst.error)
                        break;
                if (!(rt->rt6i_flags & RTF_GATEWAY))
                        continue;
                if (fl6->flowi6_oif != rt->dst.dev->ifindex)
                        continue;
                if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
                        continue;
                break;
        }

        if (!rt)
                rt = net->ipv6.ip6_null_entry;
        else if (rt->dst.error) {
                rt = net->ipv6.ip6_null_entry;
                goto out;
        }

        if (rt == net->ipv6.ip6_null_entry) {
                fn = fib6_backtrack(fn, &fl6->saddr);
                if (fn)
                        goto restart;
        }

out:
        dst_hold(&rt->dst);

        read_unlock_bh(&table->tb6_lock);

        return rt;
};

static struct dst_entry *ip6_route_redirect(struct net *net,
                                        const struct flowi6 *fl6,
                                        const struct in6_addr *gateway)
{
        int flags = RT6_LOOKUP_F_HAS_SADDR;
        struct ip6rd_flowi rdfl;

        rdfl.fl6 = *fl6;
        rdfl.gateway = *gateway;

        return fib6_rule_lookup(net, &rdfl.fl6,
                                flags, __ip6_route_redirect);
}

void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
{
        const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
        struct dst_entry *dst;
        struct flowi6 fl6;

        memset(&fl6, 0, sizeof(fl6));
        fl6.flowi6_oif = oif;
        fl6.flowi6_mark = mark;
        fl6.flowi6_flags = 0;
        fl6.daddr = iph->daddr;
        fl6.saddr = iph->saddr;
        fl6.flowlabel = ip6_flowinfo(iph);

        dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
        rt6_do_redirect(dst, NULL, skb);
        dst_release(dst);
}
EXPORT_SYMBOL_GPL(ip6_redirect);

void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
                            u32 mark)
{
        const struct ipv6hdr *iph = ipv6_hdr(skb);
        const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
        struct dst_entry *dst;
        struct flowi6 fl6;

        memset(&fl6, 0, sizeof(fl6));
        fl6.flowi6_oif = oif;
        fl6.flowi6_mark = mark;
        fl6.flowi6_flags = 0;
        fl6.daddr = msg->dest;
        fl6.saddr = iph->daddr;

        dst = ip6_route_redirect(net, &fl6, &iph->saddr);
        rt6_do_redirect(dst, NULL, skb);
        dst_release(dst);
}

void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
{
        ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
}
EXPORT_SYMBOL_GPL(ip6_sk_redirect);

static unsigned int ip6_default_advmss(const struct dst_entry *dst)
{
        struct net_device *dev = dst->dev;
        unsigned int mtu = dst_mtu(dst);
        struct net *net = dev_net(dev);

        mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);

        if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
                mtu = net->ipv6.sysctl.ip6_rt_min_advmss;

        /*
         * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
         * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
         * IPV6_MAXPLEN is also valid and means: "any MSS,
         * rely only on pmtu discovery"
         */
        if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
                mtu = IPV6_MAXPLEN;
        return mtu;
}

static unsigned int ip6_mtu(const struct dst_entry *dst)
{
        const struct rt6_info *rt = (const struct rt6_info *)dst;
        unsigned int mtu = rt->rt6i_pmtu;
        struct inet6_dev *idev;

        if (mtu)
                goto out;

        mtu = dst_metric_raw(dst, RTAX_MTU);
        if (mtu)
                goto out;

        mtu = IPV6_MIN_MTU;

        rcu_read_lock();
        idev = __in6_dev_get(dst->dev);
        if (idev)
                mtu = idev->cnf.mtu6;
        rcu_read_unlock();

out:
        return min_t(unsigned int, mtu, IP6_MAX_MTU);
}

static struct dst_entry *icmp6_dst_gc_list;
static DEFINE_SPINLOCK(icmp6_dst_lock);

struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
                                  struct flowi6 *fl6)
{
        struct dst_entry *dst;
        struct rt6_info *rt;
        struct inet6_dev *idev = in6_dev_get(dev);
        struct net *net = dev_net(dev);

        if (unlikely(!idev))
                return ERR_PTR(-ENODEV);

        rt = ip6_dst_alloc(net, dev, 0);
        if (unlikely(!rt)) {
                in6_dev_put(idev);
                dst = ERR_PTR(-ENOMEM);
                goto out;
        }

        rt->dst.flags |= DST_HOST;
        rt->dst.output  = ip6_output;
        atomic_set(&rt->dst.__refcnt, 1);
        rt->rt6i_gateway  = fl6->daddr;
        rt->rt6i_dst.addr = fl6->daddr;
        rt->rt6i_dst.plen = 128;
        rt->rt6i_idev     = idev;
        dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);

        spin_lock_bh(&icmp6_dst_lock);
        rt->dst.next = icmp6_dst_gc_list;
        icmp6_dst_gc_list = &rt->dst;
        spin_unlock_bh(&icmp6_dst_lock);

        fib6_force_start_gc(net);

        dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);

out:
        return dst;
}

int icmp6_dst_gc(void)
{
        struct dst_entry *dst, **pprev;
        int more = 0;

        spin_lock_bh(&icmp6_dst_lock);
        pprev = &icmp6_dst_gc_list;

        while ((dst = *pprev) != NULL) {
                if (!atomic_read(&dst->__refcnt)) {
                        *pprev = dst->next;
                        dst_free(dst);
                } else {
                        pprev = &dst->next;
                        ++more;
                }
        }

        spin_unlock_bh(&icmp6_dst_lock);

        return more;
}

static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
                            void *arg)
{
        struct dst_entry *dst, **pprev;

        spin_lock_bh(&icmp6_dst_lock);
        pprev = &icmp6_dst_gc_list;
        while ((dst = *pprev) != NULL) {
                struct rt6_info *rt = (struct rt6_info *) dst;
                if (func(rt, arg)) {
                        *pprev = dst->next;
                        dst_free(dst);
                } else {
                        pprev = &dst->next;
                }
        }
        spin_unlock_bh(&icmp6_dst_lock);
}

static int ip6_dst_gc(struct dst_ops *ops)
{
        struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
        int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
        int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
        int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
        int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
        unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
        int entries;

        entries = dst_entries_get_fast(ops);
        if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
            entries <= rt_max_size)
                goto out;

        net->ipv6.ip6_rt_gc_expire++;
        fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, entries > rt_max_size);
        entries = dst_entries_get_slow(ops);
        if (entries < ops->gc_thresh)
                net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
out:
        net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
        return entries > rt_max_size;
}

static int ip6_convert_metrics(struct mx6_config *mxc,
                               const struct fib6_config *cfg)
{
        bool ecn_ca = false;
        struct nlattr *nla;
        int remaining;
        u32 *mp;

        if (cfg->fc_mx == NULL)
                return 0;

        mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
        if (unlikely(!mp))
                return -ENOMEM;

        nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
                int type = nla_type(nla);
                u32 val;

                if (!type)
                        continue;
                if (unlikely(type > RTAX_MAX))
                        goto err;

                if (type == RTAX_CC_ALGO) {
                        char tmp[TCP_CA_NAME_MAX];

                        nla_strlcpy(tmp, nla, sizeof(tmp));
                        val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
                        if (val == TCP_CA_UNSPEC)
                                goto err;
                } else {
                        val = nla_get_u32(nla);
                }
                if (type == RTAX_HOPLIMIT && val > 255)
                        val = 255;
                if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
                        goto err;

                mp[type - 1] = val;
                __set_bit(type - 1, mxc->mx_valid);
        }

        if (ecn_ca) {
                __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
                mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
        }

        mxc->mx = mp;
        return 0;
 err:
        kfree(mp);
        return -EINVAL;
}

int ip6_route_info_create(struct fib6_config *cfg, struct rt6_info **rt_ret)
{
        int err;
        struct net *net = cfg->fc_nlinfo.nl_net;
        struct rt6_info *rt = NULL;
        struct net_device *dev = NULL;
        struct inet6_dev *idev = NULL;
        struct fib6_table *table;
        int addr_type;

        if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
                return -EINVAL;
#ifndef CONFIG_IPV6_SUBTREES
        if (cfg->fc_src_len)
                return -EINVAL;
#endif
        if (cfg->fc_ifindex) {
                err = -ENODEV;
                dev = dev_get_by_index(net, cfg->fc_ifindex);
                if (!dev)
                        goto out;
                idev = in6_dev_get(dev);
                if (!idev)
                        goto out;
        }

        if (cfg->fc_metric == 0)
                cfg->fc_metric = IP6_RT_PRIO_USER;

        err = -ENOBUFS;
        if (cfg->fc_nlinfo.nlh &&
            !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
                table = fib6_get_table(net, cfg->fc_table);
                if (!table) {
                        pr_warn("NLM_F_CREATE should be specified when creating new route\n");
                        table = fib6_new_table(net, cfg->fc_table);
                }
        } else {
                table = fib6_new_table(net, cfg->fc_table);
        }

        if (!table)
                goto out;

        rt = ip6_dst_alloc(net, NULL,
                           (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);

        if (!rt) {
                err = -ENOMEM;
                goto out;
        }

        if (cfg->fc_flags & RTF_EXPIRES)
                rt6_set_expires(rt, jiffies +
                                clock_t_to_jiffies(cfg->fc_expires));
        else
                rt6_clean_expires(rt);

        if (cfg->fc_protocol == RTPROT_UNSPEC)
                cfg->fc_protocol = RTPROT_BOOT;
        rt->rt6i_protocol = cfg->fc_protocol;

        addr_type = ipv6_addr_type(&cfg->fc_dst);

        if (addr_type & IPV6_ADDR_MULTICAST)
                rt->dst.input = ip6_mc_input;
        else if (cfg->fc_flags & RTF_LOCAL)
                rt->dst.input = ip6_input;
        else
                rt->dst.input = ip6_forward;

        rt->dst.output = ip6_output;

        if (cfg->fc_encap) {
                struct lwtunnel_state *lwtstate;

                err = lwtunnel_build_state(dev, cfg->fc_encap_type,
                                           cfg->fc_encap, AF_INET6, cfg,
                                           &lwtstate);
                if (err)
                        goto out;
                rt->dst.lwtstate = lwtstate_get(lwtstate);
                if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
                        rt->dst.lwtstate->orig_output = rt->dst.output;
                        rt->dst.output = lwtunnel_output;
                }
                if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
                        rt->dst.lwtstate->orig_input = rt->dst.input;
                        rt->dst.input = lwtunnel_input;
                }
        }

        ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
        rt->rt6i_dst.plen = cfg->fc_dst_len;
        if (rt->rt6i_dst.plen == 128)
                rt->dst.flags |= DST_HOST;

#ifdef CONFIG_IPV6_SUBTREES
        ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
        rt->rt6i_src.plen = cfg->fc_src_len;
#endif

        rt->rt6i_metric = cfg->fc_metric;

        /* We cannot add true routes via loopback here,
           they would result in kernel looping; promote them to reject routes
         */
        if ((cfg->fc_flags & RTF_REJECT) ||
            (dev && (dev->flags & IFF_LOOPBACK) &&
             !(addr_type & IPV6_ADDR_LOOPBACK) &&
             !(cfg->fc_flags & RTF_LOCAL))) {
                /* hold loopback dev/idev if we haven't done so. */
                if (dev != net->loopback_dev) {
                        if (dev) {
                                dev_put(dev);
                                in6_dev_put(idev);
                        }
                        dev = net->loopback_dev;
                        dev_hold(dev);
                        idev = in6_dev_get(dev);
                        if (!idev) {
                                err = -ENODEV;
                                goto out;
                        }
                }
                rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
                switch (cfg->fc_type) {
                case RTN_BLACKHOLE:
                        rt->dst.error = -EINVAL;
                        rt->dst.output = dst_discard_sk;
                        rt->dst.input = dst_discard;
                        break;
                case RTN_PROHIBIT:
                        rt->dst.error = -EACCES;
                        rt->dst.output = ip6_pkt_prohibit_out;
                        rt->dst.input = ip6_pkt_prohibit;
                        break;
                case RTN_THROW:
                case RTN_UNREACHABLE:
                default:
                        rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
                                        : (cfg->fc_type == RTN_UNREACHABLE)
                                        ? -EHOSTUNREACH : -ENETUNREACH;
                        rt->dst.output = ip6_pkt_discard_out;
                        rt->dst.input = ip6_pkt_discard;
                        break;
                }
                goto install_route;
        }

        if (cfg->fc_flags & RTF_GATEWAY) {
                const struct in6_addr *gw_addr;
                int gwa_type;

                gw_addr = &cfg->fc_gateway;
                gwa_type = ipv6_addr_type(gw_addr);

                /* if gw_addr is local we will fail to detect this in case
                 * address is still TENTATIVE (DAD in progress). rt6_lookup()
                 * will return already-added prefix route via interface that
                 * prefix route was assigned to, which might be non-loopback.
                 */
                err = -EINVAL;
                if (ipv6_chk_addr_and_flags(net, gw_addr,
                                            gwa_type & IPV6_ADDR_LINKLOCAL ?
                                            dev : NULL, 0, 0))
                        goto out;

                rt->rt6i_gateway = *gw_addr;

                if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
                        struct rt6_info *grt;

                        /* IPv6 strictly inhibits using not link-local
                           addresses as nexthop address.
                           Otherwise, router will not able to send redirects.
                           It is very good, but in some (rare!) circumstances
                           (SIT, PtP, NBMA NOARP links) it is handy to allow
                           some exceptions. --ANK
                         */
                        if (!(gwa_type & IPV6_ADDR_UNICAST))
                                goto out;

                        grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);

                        err = -EHOSTUNREACH;
                        if (!grt)
                                goto out;
                        if (dev) {
                                if (dev != grt->dst.dev) {
                                        ip6_rt_put(grt);
                                        goto out;
                                }
                        } else {
                                dev = grt->dst.dev;
                                idev = grt->rt6i_idev;
                                dev_hold(dev);
                                in6_dev_hold(grt->rt6i_idev);

                        }
                        if (!(grt->rt6i_flags & RTF_GATEWAY))
                                err = 0;
                        ip6_rt_put(grt);

                        if (err)
                                goto out;
                }
                err = -EINVAL;
                if (!dev || (dev->flags & IFF_LOOPBACK))
                        goto out;
        }

        err = -ENODEV;
        if (!dev)
                goto out;

        if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
                if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
                        err = -EINVAL;
                        goto out;
                }
                rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
                rt->rt6i_prefsrc.plen = 128;
        } else
                rt->rt6i_prefsrc.plen = 0;

        rt->rt6i_flags = cfg->fc_flags;

install_route:
        rt->dst.dev = dev;
        rt->rt6i_idev = idev;
        rt->rt6i_table = table;

        cfg->fc_nlinfo.nl_net = dev_net(dev);

        *rt_ret = rt;

        return 0;
out:
        if (dev)
                dev_put(dev);
        if (idev)
                in6_dev_put(idev);
        if (rt)
                dst_free(&rt->dst);

        *rt_ret = NULL;

        return err;
}

int ip6_route_add(struct fib6_config *cfg)
{
        struct mx6_config mxc = { .mx = NULL, };
        struct rt6_info *rt = NULL;
        int err;

        err = ip6_route_info_create(cfg, &rt);
        if (err)
                goto out;

        err = ip6_convert_metrics(&mxc, cfg);
        if (err)
                goto out;

        err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);

        kfree(mxc.mx);

        return err;
out:
        if (rt)
                dst_free(&rt->dst);

        return err;
}

static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
{
        int err;
        struct fib6_table *table;
        struct net *net = dev_net(rt->dst.dev);

        if (rt == net->ipv6.ip6_null_entry ||
            rt->dst.flags & DST_NOCACHE) {
                err = -ENOENT;
                goto out;
        }

        table = rt->rt6i_table;
        write_lock_bh(&table->tb6_lock);
        err = fib6_del(rt, info);
        write_unlock_bh(&table->tb6_lock);

out:
        ip6_rt_put(rt);
        return err;
}

int ip6_del_rt(struct rt6_info *rt)
{
        struct nl_info info = {
                .nl_net = dev_net(rt->dst.dev),
        };
        return __ip6_del_rt(rt, &info);
}

static int ip6_route_del(struct fib6_config *cfg)
{
        struct fib6_table *table;
        struct fib6_node *fn;
        struct rt6_info *rt;
        int err = -ESRCH;

        table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
        if (!table)
                return err;

        read_lock_bh(&table->tb6_lock);

        fn = fib6_locate(&table->tb6_root,
                         &cfg->fc_dst, cfg->fc_dst_len,
                         &cfg->fc_src, cfg->fc_src_len);

        if (fn) {
                for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
                        if ((rt->rt6i_flags & RTF_CACHE) &&
                            !(cfg->fc_flags & RTF_CACHE))
                                continue;
                        if (cfg->fc_ifindex &&
                            (!rt->dst.dev ||
                             rt->dst.dev->ifindex != cfg->fc_ifindex))
                                continue;
                        if (cfg->fc_flags & RTF_GATEWAY &&
                            !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
                                continue;
                        if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
                                continue;
                        dst_hold(&rt->dst);
                        read_unlock_bh(&table->tb6_lock);

                        return __ip6_del_rt(rt, &cfg->fc_nlinfo);
                }
        }
        read_unlock_bh(&table->tb6_lock);

        return err;
}

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
{
        struct netevent_redirect netevent;
        struct rt6_info *rt, *nrt = NULL;
        struct ndisc_options ndopts;
        struct inet6_dev *in6_dev;
        struct neighbour *neigh;
        struct rd_msg *msg;
        int optlen, on_link;
        u8 *lladdr;

        optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
        optlen -= sizeof(*msg);

        if (optlen < 0) {
                net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
                return;
        }

        msg = (struct rd_msg *)icmp6_hdr(skb);

        if (ipv6_addr_is_multicast(&msg->dest)) {
                net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
                return;
        }

        on_link = 0;
        if (ipv6_addr_equal(&msg->dest, &msg->target)) {
                on_link = 1;
        } else if (ipv6_addr_type(&msg->target) !=
                   (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
                net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
                return;
        }

        in6_dev = __in6_dev_get(skb->dev);
        if (!in6_dev)
                return;
        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
                return;

        /* RFC2461 8.1:
         *      The IP source address of the Redirect MUST be the same as the current
         *      first-hop router for the specified ICMP Destination Address.
         */

        if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
                net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
                return;
        }

        lladdr = NULL;
        if (ndopts.nd_opts_tgt_lladdr) {
                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
                                             skb->dev);
                if (!lladdr) {
                        net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
                        return;
                }
        }

        rt = (struct rt6_info *) dst;
        if (rt->rt6i_flags & RTF_REJECT) {
                net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
                return;
        }

        /* Redirect received -> path was valid.
         * Look, redirects are sent only in response to data packets,
         * so that this nexthop apparently is reachable. --ANK
         */
        dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);

        neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
        if (!neigh)
                return;

        /*
         *      We have finally decided to accept it.
         */

        ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
                     NEIGH_UPDATE_F_WEAK_OVERRIDE|
                     NEIGH_UPDATE_F_OVERRIDE|
                     (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
                                     NEIGH_UPDATE_F_ISROUTER)),
                     NDISC_REDIRECT, &ndopts);

        nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
        if (!nrt)
                goto out;

        nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
        if (on_link)
                nrt->rt6i_flags &= ~RTF_GATEWAY;

        nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;

        if (ip6_ins_rt(nrt))
                goto out;

        netevent.old = &rt->dst;
        netevent.new = &nrt->dst;
        netevent.daddr = &msg->dest;
        netevent.neigh = neigh;
        call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);

        if (rt->rt6i_flags & RTF_CACHE) {
                rt = (struct rt6_info *) dst_clone(&rt->dst);
                ip6_del_rt(rt);
        }

out:
        neigh_release(neigh);
}

/*
 *      Misc support functions
 */

static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
{
        BUG_ON(from->dst.from);

        rt->rt6i_flags &= ~RTF_EXPIRES;
        dst_hold(&from->dst);
        rt->dst.from = &from->dst;
        dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
}

static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
{
        rt->dst.input = ort->dst.input;
        rt->dst.output = ort->dst.output;
        rt->rt6i_dst = ort->rt6i_dst;
        rt->dst.error = ort->dst.error;
        rt->rt6i_idev = ort->rt6i_idev;
        if (rt->rt6i_idev)
                in6_dev_hold(rt->rt6i_idev);
        rt->dst.lastuse = jiffies;
        rt->rt6i_gateway = ort->rt6i_gateway;
        rt->rt6i_flags = ort->rt6i_flags;
        rt6_set_from(rt, ort);
        rt->rt6i_metric = ort->rt6i_metric;
#ifdef CONFIG_IPV6_SUBTREES
        rt->rt6i_src = ort->rt6i_src;
#endif
        rt->rt6i_prefsrc = ort->rt6i_prefsrc;
        rt->rt6i_table = ort->rt6i_table;
        rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
}

#ifdef CONFIG_IPV6_ROUTE_INFO
static struct rt6_info *rt6_get_route_info(struct net *net,
                                           const struct in6_addr *prefix, int prefixlen,
                                           const struct in6_addr *gwaddr, int ifindex)
{
        struct fib6_node *fn;
        struct rt6_info *rt = NULL;
        struct fib6_table *table;

        table = fib6_get_table(net, RT6_TABLE_INFO);
        if (!table)
                return NULL;

        read_lock_bh(&table->tb6_lock);
        fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
        if (!fn)
                goto out;

        for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
                if (rt->dst.dev->ifindex != ifindex)
                        continue;
                if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
                        continue;
                if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
                        continue;
                dst_hold(&rt->dst);
                break;
        }
out:
        read_unlock_bh(&table->tb6_lock);
        return rt;
}

static struct rt6_info *rt6_add_route_info(struct net *net,
                                           const struct in6_addr *prefix, int prefixlen,
                                           const struct in6_addr *gwaddr, int ifindex,
                                           unsigned int pref)
{
        struct fib6_config cfg = {
                .fc_table       = RT6_TABLE_INFO,
                .fc_metric      = IP6_RT_PRIO_USER,
                .fc_ifindex     = ifindex,
                .fc_dst_len     = prefixlen,
                .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
                                  RTF_UP | RTF_PREF(pref),
                .fc_nlinfo.portid = 0,
                .fc_nlinfo.nlh = NULL,
                .fc_nlinfo.nl_net = net,
        };

        cfg.fc_dst = *prefix;
        cfg.fc_gateway = *gwaddr;

        /* We should treat it as a default route if prefix length is 0. */
        if (!prefixlen)
                cfg.fc_flags |= RTF_DEFAULT;

        ip6_route_add(&cfg);

        return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
}
#endif

struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
{
        struct rt6_info *rt;
        struct fib6_table *table;

        table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
        if (!table)
                return NULL;

        read_lock_bh(&table->tb6_lock);
        for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
                if (dev == rt->dst.dev &&
                    ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
                    ipv6_addr_equal(&rt->rt6i_gateway, addr))
                        break;
        }
        if (rt)
                dst_hold(&rt->dst);
        read_unlock_bh(&table->tb6_lock);
        return rt;
}

struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
                                     struct net_device *dev,
                                     unsigned int pref)
{
        struct fib6_config cfg = {
                .fc_table       = RT6_TABLE_DFLT,
                .fc_metric      = IP6_RT_PRIO_USER,
                .fc_ifindex     = dev->ifindex,
                .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
                                  RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
                .fc_nlinfo.portid = 0,
                .fc_nlinfo.nlh = NULL,
                .fc_nlinfo.nl_net = dev_net(dev),
        };

        cfg.fc_gateway = *gwaddr;

        ip6_route_add(&cfg);

        return rt6_get_dflt_router(gwaddr, dev);
}

void rt6_purge_dflt_routers(struct net *net)
{
        struct rt6_info *rt;
        struct fib6_table *table;

        /* NOTE: Keep consistent with rt6_get_dflt_router */
        table = fib6_get_table(net, RT6_TABLE_DFLT);
        if (!table)
                return;

restart:
        read_lock_bh(&table->tb6_lock);
        for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
                if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
                    (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
                        dst_hold(&rt->dst);
                        read_unlock_bh(&table->tb6_lock);
                        ip6_del_rt(rt);
                        goto restart;
                }
        }
        read_unlock_bh(&table->tb6_lock);
}

static void rtmsg_to_fib6_config(struct net *net,
                                 struct in6_rtmsg *rtmsg,
                                 struct fib6_config *cfg)
{
        memset(cfg, 0, sizeof(*cfg));

        cfg->fc_table = RT6_TABLE_MAIN;
        cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
        cfg->fc_metric = rtmsg->rtmsg_metric;
        cfg->fc_expires = rtmsg->rtmsg_info;
        cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
        cfg->fc_src_len = rtmsg->rtmsg_src_len;
        cfg->fc_flags = rtmsg->rtmsg_flags;

        cfg->fc_nlinfo.nl_net = net;

        cfg->fc_dst = rtmsg->rtmsg_dst;
        cfg->fc_src = rtmsg->rtmsg_src;
        cfg->fc_gateway = rtmsg->rtmsg_gateway;
}

int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
{
        struct fib6_config cfg;
        struct in6_rtmsg rtmsg;
        int err;

        switch(cmd) {
        case SIOCADDRT:         /* Add a route */
        case SIOCDELRT:         /* Delete a route */
                if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
                        return -EPERM;
                err = copy_from_user(&rtmsg, arg,
                                     sizeof(struct in6_rtmsg));
                if (err)
                        return -EFAULT;

                rtmsg_to_fib6_config(net, &rtmsg, &cfg);

                rtnl_lock();
                switch (cmd) {
                case SIOCADDRT:
                        err = ip6_route_add(&cfg);
                        break;
                case SIOCDELRT:
                        err = ip6_route_del(&cfg);
                        break;
                default:
                        err = -EINVAL;
                }
                rtnl_unlock();

                return err;
        }

        return -EINVAL;
}

/*
 *      Drop the packet on the floor
 */

static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
{
        int type;
        struct dst_entry *dst = skb_dst(skb);
        switch (ipstats_mib_noroutes) {
        case IPSTATS_MIB_INNOROUTES:
                type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
                if (type == IPV6_ADDR_ANY) {
                        IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
                                      IPSTATS_MIB_INADDRERRORS);
                        break;
                }
                /* FALLTHROUGH */
        case IPSTATS_MIB_OUTNOROUTES:
                IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
                              ipstats_mib_noroutes);
                break;
        }
        icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
        kfree_skb(skb);
        return 0;
}

static int ip6_pkt_discard(struct sk_buff *skb)
{
        return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
}

static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
{
        skb->dev = skb_dst(skb)->dev;
        return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
}

static int ip6_pkt_prohibit(struct sk_buff *skb)
{
        return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
}

static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
{
        skb->dev = skb_dst(skb)->dev;
        return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
}

/*
 *      Allocate a dst for local (unicast / anycast) address.
 */

struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
                                    const struct in6_addr *addr,
                                    bool anycast)
{
        struct net *net = dev_net(idev->dev);
        struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
                                            DST_NOCOUNT);
        if (!rt)
                return ERR_PTR(-ENOMEM);

        in6_dev_hold(idev);

        rt->dst.flags |= DST_HOST;
        rt->dst.input = ip6_input;
        rt->dst.output = ip6_output;
        rt->rt6i_idev = idev;

        rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
        if (anycast)
                rt->rt6i_flags |= RTF_ANYCAST;
        else
                rt->rt6i_flags |= RTF_LOCAL;

        rt->rt6i_gateway  = *addr;
        rt->rt6i_dst.addr = *addr;
        rt->rt6i_dst.plen = 128;
        rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
        rt->dst.flags |= DST_NOCACHE;

        atomic_set(&rt->dst.__refcnt, 1);

        return rt;
}

int ip6_route_get_saddr(struct net *net,
                        struct rt6_info *rt,
                        const struct in6_addr *daddr,
                        unsigned int prefs,
                        struct in6_addr *saddr)
{
        struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
        int err = 0;
        if (rt->rt6i_prefsrc.plen)
                *saddr = rt->rt6i_prefsrc.addr;
        else
                err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
                                         daddr, prefs, saddr);
        return err;
}

/* remove deleted ip from prefsrc entries */
struct arg_dev_net_ip {
        struct net_device *dev;
        struct net *net;
        struct in6_addr *addr;
};

static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
{
        struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
        struct net *net = ((struct arg_dev_net_ip *)arg)->net;
        struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;

        if (((void *)rt->dst.dev == dev || !dev) &&
            rt != net->ipv6.ip6_null_entry &&
            ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
                /* remove prefsrc entry */
                rt->rt6i_prefsrc.plen = 0;
        }
        return 0;
}

void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
{
        struct net *net = dev_net(ifp->idev->dev);
        struct arg_dev_net_ip adni = {
                .dev = ifp->idev->dev,
                .net = net,
                .addr = &ifp->addr,
        };
        fib6_clean_all(net, fib6_remove_prefsrc, &adni);
}

#define RTF_RA_ROUTER           (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
#define RTF_CACHE_GATEWAY       (RTF_GATEWAY | RTF_CACHE)

/* Remove routers and update dst entries when gateway turn into host. */
static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
{
        struct in6_addr *gateway = (struct in6_addr *)arg;

        if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
             ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
             ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
                return -1;
        }
        return 0;
}

void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
{
        fib6_clean_all(net, fib6_clean_tohost, gateway);
}

struct arg_dev_net {
        struct net_device *dev;
        struct net *net;
};

static int fib6_ifdown(struct rt6_info *rt, void *arg)
{
        const struct arg_dev_net *adn = arg;
        const struct net_device *dev = adn->dev;

        if ((rt->dst.dev == dev || !dev) &&
            rt != adn->net->ipv6.ip6_null_entry)
                return -1;

        return 0;
}

void rt6_ifdown(struct net *net, struct net_device *dev)
{
        struct arg_dev_net adn = {
                .dev = dev,
                .net = net,
        };

        fib6_clean_all(net, fib6_ifdown, &adn);
        icmp6_clean_all(fib6_ifdown, &adn);
        if (dev)
                rt6_uncached_list_flush_dev(net, dev);
}

struct rt6_mtu_change_arg {
        struct net_device *dev;
        unsigned int mtu;
};

static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
{
        struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
        struct inet6_dev *idev;

        /* In IPv6 pmtu discovery is not optional,
           so that RTAX_MTU lock cannot disable it.
           We still use this lock to block changes
           caused by addrconf/ndisc.
        */

        idev = __in6_dev_get(arg->dev);
        if (!idev)
                return 0;

        /* For administrative MTU increase, there is no way to discover
           IPv6 PMTU increase, so PMTU increase should be updated here.
           Since RFC 1981 doesn't include administrative MTU increase
           update PMTU increase is a MUST. (i.e. jumbo frame)
         */
        /*
           If new MTU is less than route PMTU, this new MTU will be the
           lowest MTU in the path, update the route PMTU to reflect PMTU
           decreases; if new MTU is greater than route PMTU, and the
           old MTU is the lowest MTU in the path, update the route PMTU
           to reflect the increase. In this case if the other nodes' MTU
           also have the lowest MTU, TOO BIG MESSAGE will be lead to
           PMTU discouvery.
         */
        if (rt->dst.dev == arg->dev &&
            !dst_metric_locked(&rt->dst, RTAX_MTU)) {
                if (rt->rt6i_flags & RTF_CACHE) {
                        /* For RTF_CACHE with rt6i_pmtu == 0
                         * (i.e. a redirected route),
                         * the metrics of its rt->dst.from has already
                         * been updated.
                         */
                        if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
                                rt->rt6i_pmtu = arg->mtu;
                } else if (dst_mtu(&rt->dst) >= arg->mtu ||
                           (dst_mtu(&rt->dst) < arg->mtu &&
                            dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
                        dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
                }
        }
        return 0;
}

void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
{
        struct rt6_mtu_change_arg arg = {
                .dev = dev,
                .mtu = mtu,
        };

        fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
}

static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
        [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
        [RTA_OIF]               = { .type = NLA_U32 },
        [RTA_IIF]               = { .type = NLA_U32 },
        [RTA_PRIORITY]          = { .type = NLA_U32 },
        [RTA_METRICS]           = { .type = NLA_NESTED },
        [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
        [RTA_PREF]              = { .type = NLA_U8 },
        [RTA_ENCAP_TYPE]        = { .type = NLA_U16 },
        [RTA_ENCAP]             = { .type = NLA_NESTED },
        [RTA_EXPIRES]           = { .type = NLA_U32 },
};

static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
                              struct fib6_config *cfg)
{
        struct rtmsg *rtm;
        struct nlattr *tb[RTA_MAX+1];
        unsigned int pref;
        int err;

        err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
        if (err < 0)
                goto errout;

        err = -EINVAL;
        rtm = nlmsg_data(nlh);
        memset(cfg, 0, sizeof(*cfg));

        cfg->fc_table = rtm->rtm_table;
        cfg->fc_dst_len = rtm->rtm_dst_len;
        cfg->fc_src_len = rtm->rtm_src_len;
        cfg->fc_flags = RTF_UP;
        cfg->fc_protocol = rtm->rtm_protocol;
        cfg->fc_type = rtm->rtm_type;

        if (rtm->rtm_type == RTN_UNREACHABLE ||
            rtm->rtm_type == RTN_BLACKHOLE ||
            rtm->rtm_type == RTN_PROHIBIT ||
            rtm->rtm_type == RTN_THROW)
                cfg->fc_flags |= RTF_REJECT;

        if (rtm->rtm_type == RTN_LOCAL)
                cfg->fc_flags |= RTF_LOCAL;

        if (rtm->rtm_flags & RTM_F_CLONED)
                cfg->fc_flags |= RTF_CACHE;

        cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
        cfg->fc_nlinfo.nlh = nlh;
        cfg->fc_nlinfo.nl_net = sock_net(skb->sk);

        if (tb[RTA_GATEWAY]) {
                cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
                cfg->fc_flags |= RTF_GATEWAY;
        }

        if (tb[RTA_DST]) {
                int plen = (rtm->rtm_dst_len + 7) >> 3;

                if (nla_len(tb[RTA_DST]) < plen)
                        goto errout;

                nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
        }

        if (tb[RTA_SRC]) {
                int plen = (rtm->rtm_src_len + 7) >> 3;

                if (nla_len(tb[RTA_SRC]) < plen)
                        goto errout;

                nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
        }

        if (tb[RTA_PREFSRC])
                cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);

        if (tb[RTA_OIF])
                cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);

        if (tb[RTA_PRIORITY])
                cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);

        if (tb[RTA_METRICS]) {
                cfg->fc_mx = nla_data(tb[RTA_METRICS]);
                cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
        }

        if (tb[RTA_TABLE])
                cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);

        if (tb[RTA_MULTIPATH]) {
                cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
                cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
        }

        if (tb[RTA_PREF]) {
                pref = nla_get_u8(tb[RTA_PREF]);
                if (pref != ICMPV6_ROUTER_PREF_LOW &&
                    pref != ICMPV6_ROUTER_PREF_HIGH)
                        pref = ICMPV6_ROUTER_PREF_MEDIUM;
                cfg->fc_flags |= RTF_PREF(pref);
        }

        if (tb[RTA_EXPIRES]) {
                unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);

                if (addrconf_finite_timeout(timeout)) {
                        cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
                        cfg->fc_flags |= RTF_EXPIRES;
                }
        }

        if (tb[RTA_ENCAP])
                cfg->fc_encap = tb[RTA_ENCAP];

        if (tb[RTA_ENCAP_TYPE])
                cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);

        err = 0;
errout:
        return err;
}

struct rt6_nh {
        struct rt6_info *rt6_info;
        struct fib6_config r_cfg;
        struct mx6_config mxc;
        struct list_head next;
};

static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
{
        struct rt6_nh *nh;

        list_for_each_entry(nh, rt6_nh_list, next) {
                pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6 nexthop %pI6 ifi %d\n",
                        &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
                        nh->r_cfg.fc_ifindex);
        }
}

static int ip6_route_info_append(struct list_head *rt6_nh_list,
                                 struct rt6_info *rt, struct fib6_config *r_cfg)
{
        struct rt6_nh *nh;
        struct rt6_info *rtnh;
        int err = -EEXIST;

        list_for_each_entry(nh, rt6_nh_list, next) {
                /* check if rt6_info already exists */
                rtnh = nh->rt6_info;

                if (rtnh->dst.dev == rt->dst.dev &&
                    rtnh->rt6i_idev == rt->rt6i_idev &&
                    ipv6_addr_equal(&rtnh->rt6i_gateway,
                                    &rt->rt6i_gateway))
                        return err;
        }

        nh = kzalloc(sizeof(*nh), GFP_KERNEL);
        if (!nh)
                return -ENOMEM;
        nh->rt6_info = rt;
        err = ip6_convert_metrics(&nh->mxc, r_cfg);
        if (err) {
                kfree(nh);
                return err;
        }
        memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
        list_add_tail(&nh->next, rt6_nh_list);

        return 0;
}

static int ip6_route_multipath_add(struct fib6_config *cfg)
{
        struct fib6_config r_cfg;
        struct rtnexthop *rtnh;
        struct rt6_info *rt;
        struct rt6_nh *err_nh;
        struct rt6_nh *nh, *nh_safe;
        int remaining;
        int attrlen;
        int err = 1;
        int nhn = 0;
        int replace = (cfg->fc_nlinfo.nlh &&
                       (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
        LIST_HEAD(rt6_nh_list);

        remaining = cfg->fc_mp_len;
        rtnh = (struct rtnexthop *)cfg->fc_mp;

        /* Parse a Multipath Entry and build a list (rt6_nh_list) of
         * rt6_info structs per nexthop
         */
        while (rtnh_ok(rtnh, remaining)) {
                memcpy(&r_cfg, cfg, sizeof(*cfg));
                if (rtnh->rtnh_ifindex)
                        r_cfg.fc_ifindex = rtnh->rtnh_ifindex;

                attrlen = rtnh_attrlen(rtnh);
                if (attrlen > 0) {
                        struct nlattr *nla, *attrs = rtnh_attrs(rtnh);

                        nla = nla_find(attrs, attrlen, RTA_GATEWAY);
                        if (nla) {
                                r_cfg.fc_gateway = nla_get_in6_addr(nla);
                                r_cfg.fc_flags |= RTF_GATEWAY;
                        }
                        r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
                        nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
                        if (nla)
                                r_cfg.fc_encap_type = nla_get_u16(nla);
                }

                err = ip6_route_info_create(&r_cfg, &rt);
                if (err)
                        goto cleanup;

                err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
                if (err) {
                        dst_free(&rt->dst);
                        goto cleanup;
                }

                rtnh = rtnh_next(rtnh, &remaining);
        }

        err_nh = NULL;
        list_for_each_entry(nh, &rt6_nh_list, next) {
                err = __ip6_ins_rt(nh->rt6_info, &cfg->fc_nlinfo, &nh->mxc);
                /* nh->rt6_info is used or freed at this point, reset to NULL*/
                nh->rt6_info = NULL;
                if (err) {
                        if (replace && nhn)
                                ip6_print_replace_route_err(&rt6_nh_list);
                        err_nh = nh;
                        goto add_errout;
                }

                /* Because each route is added like a single route we remove
                 * these flags after the first nexthop: if there is a collision,
                 * we have already failed to add the first nexthop:
                 * fib6_add_rt2node() has rejected it; when replacing, old
                 * nexthops have been replaced by first new, the rest should
                 * be added to it.
                 */
                cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
                                                     NLM_F_REPLACE);
                nhn++;
        }

        goto cleanup;

add_errout:
        /* Delete routes that were already added */
        list_for_each_entry(nh, &rt6_nh_list, next) {