source: src/linux/universal/linux-3.18/net/ipv6/route.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

File size: 77.3 KB
Line 
1/*
2 *      Linux INET6 implementation
3 *      FIB front-end.
4 *
5 *      Authors:
6 *      Pedro Roque             <roque@di.fc.ul.pt>
7 *
8 *      This program is free software; you can redistribute it and/or
9 *      modify it under the terms of the GNU General Public License
10 *      as published by the Free Software Foundation; either version
11 *      2 of the License, or (at your option) any later version.
12 */
13
14/*      Changes:
15 *
16 *      YOSHIFUJI Hideaki @USAGI
17 *              reworked default router selection.
18 *              - respect outgoing interface
19 *              - select from (probably) reachable routers (i.e.
20 *              routers in REACHABLE, STALE, DELAY or PROBE states).
21 *              - always select the same router if it is (probably)
22 *              reachable.  otherwise, round-robin the list.
23 *      Ville Nuorvala
24 *              Fixed routing subtrees.
25 */
26
27#define pr_fmt(fmt) "IPv6: " fmt
28
29#include <linux/capability.h>
30#include <linux/errno.h>
31#include <linux/export.h>
32#include <linux/types.h>
33#include <linux/times.h>
34#include <linux/socket.h>
35#include <linux/sockios.h>
36#include <linux/net.h>
37#include <linux/route.h>
38#include <linux/netdevice.h>
39#include <linux/in6.h>
40#include <linux/mroute6.h>
41#include <linux/init.h>
42#include <linux/if_arp.h>
43#include <linux/proc_fs.h>
44#include <linux/seq_file.h>
45#include <linux/nsproxy.h>
46#include <linux/slab.h>
47#include <net/net_namespace.h>
48#include <net/snmp.h>
49#include <net/ipv6.h>
50#include <net/ip6_fib.h>
51#include <net/ip6_route.h>
52#include <net/ndisc.h>
53#include <net/addrconf.h>
54#include <net/tcp.h>
55#include <linux/rtnetlink.h>
56#include <net/dst.h>
57#include <net/xfrm.h>
58#include <net/netevent.h>
59#include <net/netlink.h>
60#include <net/nexthop.h>
61
62#include <asm/uaccess.h>
63
64#ifdef CONFIG_SYSCTL
65#include <linux/sysctl.h>
66#endif
67
68enum rt6_nud_state {
69        RT6_NUD_FAIL_HARD = -3,
70        RT6_NUD_FAIL_PROBE = -2,
71        RT6_NUD_FAIL_DO_RR = -1,
72        RT6_NUD_SUCCEED = 1
73};
74
75static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
76                                    const struct in6_addr *dest);
77static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
78static unsigned int      ip6_default_advmss(const struct dst_entry *dst);
79static unsigned int      ip6_mtu(const struct dst_entry *dst);
80static struct dst_entry *ip6_negative_advice(struct dst_entry *);
81static void             ip6_dst_destroy(struct dst_entry *);
82static void             ip6_dst_ifdown(struct dst_entry *,
83                                       struct net_device *dev, int how);
84static int               ip6_dst_gc(struct dst_ops *ops);
85
86static int              ip6_pkt_discard(struct sk_buff *skb);
87static int              ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb);
88static int              ip6_pkt_prohibit(struct sk_buff *skb);
89static int              ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb);
90static void             ip6_link_failure(struct sk_buff *skb);
91static void             ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
92                                           struct sk_buff *skb, u32 mtu);
93static void             rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
94                                        struct sk_buff *skb);
95static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
96
97#ifdef CONFIG_IPV6_ROUTE_INFO
98static struct rt6_info *rt6_add_route_info(struct net *net,
99                                           const struct in6_addr *prefix, int prefixlen,
100                                           const struct in6_addr *gwaddr, int ifindex,
101                                           unsigned int pref);
102static struct rt6_info *rt6_get_route_info(struct net *net,
103                                           const struct in6_addr *prefix, int prefixlen,
104                                           const struct in6_addr *gwaddr, int ifindex);
105#endif
106
107static void rt6_bind_peer(struct rt6_info *rt, int create)
108{
109        struct inet_peer_base *base;
110        struct inet_peer *peer;
111
112        base = inetpeer_base_ptr(rt->_rt6i_peer);
113        if (!base)
114                return;
115
116        peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
117        if (peer) {
118                if (!rt6_set_peer(rt, peer))
119                        inet_putpeer(peer);
120        }
121}
122
123static struct inet_peer *__rt6_get_peer(struct rt6_info *rt, int create)
124{
125        if (rt6_has_peer(rt))
126                return rt6_peer_ptr(rt);
127
128        rt6_bind_peer(rt, create);
129        return (rt6_has_peer(rt) ? rt6_peer_ptr(rt) : NULL);
130}
131
132static struct inet_peer *rt6_get_peer_create(struct rt6_info *rt)
133{
134        return __rt6_get_peer(rt, 1);
135}
136
137static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
138{
139        struct rt6_info *rt = (struct rt6_info *) dst;
140        struct inet_peer *peer;
141        u32 *p = NULL;
142
143        if (!(rt->dst.flags & DST_HOST))
144                return dst_cow_metrics_generic(dst, old);
145
146        peer = rt6_get_peer_create(rt);
147        if (peer) {
148                u32 *old_p = __DST_METRICS_PTR(old);
149                unsigned long prev, new;
150
151                p = peer->metrics;
152                if (inet_metrics_new(peer) ||
153                    (old & DST_METRICS_FORCE_OVERWRITE))
154                        memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
155
156                new = (unsigned long) p;
157                prev = cmpxchg(&dst->_metrics, old, new);
158
159                if (prev != old) {
160                        p = __DST_METRICS_PTR(prev);
161                        if (prev & DST_METRICS_READ_ONLY)
162                                p = NULL;
163                }
164        }
165        return p;
166}
167
168static inline const void *choose_neigh_daddr(struct rt6_info *rt,
169                                             struct sk_buff *skb,
170                                             const void *daddr)
171{
172        struct in6_addr *p = &rt->rt6i_gateway;
173
174        if (!ipv6_addr_any(p))
175                return (const void *) p;
176        else if (skb)
177                return &ipv6_hdr(skb)->daddr;
178        return daddr;
179}
180
181static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
182                                          struct sk_buff *skb,
183                                          const void *daddr)
184{
185        struct rt6_info *rt = (struct rt6_info *) dst;
186        struct neighbour *n;
187
188        daddr = choose_neigh_daddr(rt, skb, daddr);
189        n = __ipv6_neigh_lookup(dst->dev, daddr);
190        if (n)
191                return n;
192        return neigh_create(&nd_tbl, daddr, dst->dev);
193}
194
195static struct dst_ops ip6_dst_ops_template = {
196        .family                 =       AF_INET6,
197        .protocol               =       cpu_to_be16(ETH_P_IPV6),
198        .gc                     =       ip6_dst_gc,
199        .gc_thresh              =       1024,
200        .check                  =       ip6_dst_check,
201        .default_advmss         =       ip6_default_advmss,
202        .mtu                    =       ip6_mtu,
203        .cow_metrics            =       ipv6_cow_metrics,
204        .destroy                =       ip6_dst_destroy,
205        .ifdown                 =       ip6_dst_ifdown,
206        .negative_advice        =       ip6_negative_advice,
207        .link_failure           =       ip6_link_failure,
208        .update_pmtu            =       ip6_rt_update_pmtu,
209        .redirect               =       rt6_do_redirect,
210        .local_out              =       __ip6_local_out,
211        .neigh_lookup           =       ip6_neigh_lookup,
212};
213
214static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
215{
216        unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
217
218        return mtu ? : dst->dev->mtu;
219}
220
221static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
222                                         struct sk_buff *skb, u32 mtu)
223{
224}
225
226static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
227                                      struct sk_buff *skb)
228{
229}
230
231static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
232                                         unsigned long old)
233{
234        return NULL;
235}
236
237static struct dst_ops ip6_dst_blackhole_ops = {
238        .family                 =       AF_INET6,
239        .protocol               =       cpu_to_be16(ETH_P_IPV6),
240        .destroy                =       ip6_dst_destroy,
241        .check                  =       ip6_dst_check,
242        .mtu                    =       ip6_blackhole_mtu,
243        .default_advmss         =       ip6_default_advmss,
244        .update_pmtu            =       ip6_rt_blackhole_update_pmtu,
245        .redirect               =       ip6_rt_blackhole_redirect,
246        .cow_metrics            =       ip6_rt_blackhole_cow_metrics,
247        .neigh_lookup           =       ip6_neigh_lookup,
248};
249
250static const u32 ip6_template_metrics[RTAX_MAX] = {
251        [RTAX_HOPLIMIT - 1] = 0,
252};
253
254static const struct rt6_info ip6_null_entry_template = {
255        .dst = {
256                .__refcnt       = ATOMIC_INIT(1),
257                .__use          = 1,
258                .obsolete       = DST_OBSOLETE_FORCE_CHK,
259                .error          = -ENETUNREACH,
260                .input          = ip6_pkt_discard,
261                .output         = ip6_pkt_discard_out,
262        },
263        .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
264        .rt6i_protocol  = RTPROT_KERNEL,
265        .rt6i_metric    = ~(u32) 0,
266        .rt6i_ref       = ATOMIC_INIT(1),
267};
268
269#ifdef CONFIG_IPV6_MULTIPLE_TABLES
270
271static const struct rt6_info ip6_prohibit_entry_template = {
272        .dst = {
273                .__refcnt       = ATOMIC_INIT(1),
274                .__use          = 1,
275                .obsolete       = DST_OBSOLETE_FORCE_CHK,
276                .error          = -EACCES,
277                .input          = ip6_pkt_prohibit,
278                .output         = ip6_pkt_prohibit_out,
279        },
280        .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
281        .rt6i_protocol  = RTPROT_KERNEL,
282        .rt6i_metric    = ~(u32) 0,
283        .rt6i_ref       = ATOMIC_INIT(1),
284};
285
286static const struct rt6_info ip6_blk_hole_entry_template = {
287        .dst = {
288                .__refcnt       = ATOMIC_INIT(1),
289                .__use          = 1,
290                .obsolete       = DST_OBSOLETE_FORCE_CHK,
291                .error          = -EINVAL,
292                .input          = dst_discard,
293                .output         = dst_discard_sk,
294        },
295        .rt6i_flags     = (RTF_REJECT | RTF_NONEXTHOP),
296        .rt6i_protocol  = RTPROT_KERNEL,
297        .rt6i_metric    = ~(u32) 0,
298        .rt6i_ref       = ATOMIC_INIT(1),
299};
300
301#endif
302
303/* allocate dst with ip6_dst_ops */
304static inline struct rt6_info *ip6_dst_alloc(struct net *net,
305                                             struct net_device *dev,
306                                             int flags,
307                                             struct fib6_table *table)
308{
309        struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
310                                        0, DST_OBSOLETE_FORCE_CHK, flags);
311
312        if (rt) {
313                struct dst_entry *dst = &rt->dst;
314
315                memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
316                rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
317                INIT_LIST_HEAD(&rt->rt6i_siblings);
318        }
319        return rt;
320}
321
322static void ip6_dst_destroy(struct dst_entry *dst)
323{
324        struct rt6_info *rt = (struct rt6_info *)dst;
325        struct inet6_dev *idev = rt->rt6i_idev;
326        struct dst_entry *from = dst->from;
327
328        if (!(rt->dst.flags & DST_HOST))
329                dst_destroy_metrics_generic(dst);
330
331        if (idev) {
332                rt->rt6i_idev = NULL;
333                in6_dev_put(idev);
334        }
335
336        dst->from = NULL;
337        dst_release(from);
338
339        if (rt6_has_peer(rt)) {
340                struct inet_peer *peer = rt6_peer_ptr(rt);
341                inet_putpeer(peer);
342        }
343}
344
345static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
346                           int how)
347{
348        struct rt6_info *rt = (struct rt6_info *)dst;
349        struct inet6_dev *idev = rt->rt6i_idev;
350        struct net_device *loopback_dev =
351                dev_net(dev)->loopback_dev;
352
353        if (dev != loopback_dev) {
354                if (idev && idev->dev == dev) {
355                        struct inet6_dev *loopback_idev =
356                                in6_dev_get(loopback_dev);
357                        if (loopback_idev) {
358                                rt->rt6i_idev = loopback_idev;
359                                in6_dev_put(idev);
360                        }
361                }
362        }
363}
364
365static bool rt6_check_expired(const struct rt6_info *rt)
366{
367        if (rt->rt6i_flags & RTF_EXPIRES) {
368                if (time_after(jiffies, rt->dst.expires))
369                        return true;
370        } else if (rt->dst.from) {
371                return rt6_check_expired((struct rt6_info *) rt->dst.from);
372        }
373        return false;
374}
375
376/* Multipath route selection:
377 *   Hash based function using packet header and flowlabel.
378 * Adapted from fib_info_hashfn()
379 */
380static int rt6_info_hash_nhsfn(unsigned int candidate_count,
381                               const struct flowi6 *fl6)
382{
383        unsigned int val = fl6->flowi6_proto;
384
385        val ^= ipv6_addr_hash(&fl6->daddr);
386        val ^= ipv6_addr_hash(&fl6->saddr);
387
388        /* Work only if this not encapsulated */
389        switch (fl6->flowi6_proto) {
390        case IPPROTO_UDP:
391        case IPPROTO_TCP:
392        case IPPROTO_SCTP:
393                val ^= (__force u16)fl6->fl6_sport;
394                val ^= (__force u16)fl6->fl6_dport;
395                break;
396
397        case IPPROTO_ICMPV6:
398                val ^= (__force u16)fl6->fl6_icmp_type;
399                val ^= (__force u16)fl6->fl6_icmp_code;
400                break;
401        }
402        /* RFC6438 recommands to use flowlabel */
403        val ^= (__force u32)fl6->flowlabel;
404
405        /* Perhaps, we need to tune, this function? */
406        val = val ^ (val >> 7) ^ (val >> 12);
407        return val % candidate_count;
408}
409
410static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
411                                             struct flowi6 *fl6, int oif,
412                                             int strict)
413{
414        struct rt6_info *sibling, *next_sibling;
415        int route_choosen;
416
417        route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
418        /* Don't change the route, if route_choosen == 0
419         * (siblings does not include ourself)
420         */
421        if (route_choosen)
422                list_for_each_entry_safe(sibling, next_sibling,
423                                &match->rt6i_siblings, rt6i_siblings) {
424                        route_choosen--;
425                        if (route_choosen == 0) {
426                                if (rt6_score_route(sibling, oif, strict) < 0)
427                                        break;
428                                match = sibling;
429                                break;
430                        }
431                }
432        return match;
433}
434
435/*
436 *      Route lookup. Any table->tb6_lock is implied.
437 */
438
439static inline struct rt6_info *rt6_device_match(struct net *net,
440                                                    struct rt6_info *rt,
441                                                    const struct in6_addr *saddr,
442                                                    int oif,
443                                                    int flags)
444{
445        struct rt6_info *local = NULL;
446        struct rt6_info *sprt;
447
448        if (!oif && ipv6_addr_any(saddr))
449                goto out;
450
451        for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
452                struct net_device *dev = sprt->dst.dev;
453
454                if (oif) {
455                        if (dev->ifindex == oif)
456                                return sprt;
457                        if (dev->flags & IFF_LOOPBACK) {
458                                if (!sprt->rt6i_idev ||
459                                    sprt->rt6i_idev->dev->ifindex != oif) {
460                                        if (flags & RT6_LOOKUP_F_IFACE && oif)
461                                                continue;
462                                        if (local && (!oif ||
463                                                      local->rt6i_idev->dev->ifindex == oif))
464                                                continue;
465                                }
466                                local = sprt;
467                        }
468                } else {
469                        if (ipv6_chk_addr(net, saddr, dev,
470                                          flags & RT6_LOOKUP_F_IFACE))
471                                return sprt;
472                }
473        }
474
475        if (oif) {
476                if (local)
477                        return local;
478
479                if (flags & RT6_LOOKUP_F_IFACE)
480                        return net->ipv6.ip6_null_entry;
481        }
482out:
483        return rt;
484}
485
486#ifdef CONFIG_IPV6_ROUTER_PREF
487struct __rt6_probe_work {
488        struct work_struct work;
489        struct in6_addr target;
490        struct net_device *dev;
491};
492
493static void rt6_probe_deferred(struct work_struct *w)
494{
495        struct in6_addr mcaddr;
496        struct __rt6_probe_work *work =
497                container_of(w, struct __rt6_probe_work, work);
498
499        addrconf_addr_solict_mult(&work->target, &mcaddr);
500        ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);
501        dev_put(work->dev);
502        kfree(w);
503}
504
505static void rt6_probe(struct rt6_info *rt)
506{
507        struct neighbour *neigh;
508        /*
509         * Okay, this does not seem to be appropriate
510         * for now, however, we need to check if it
511         * is really so; aka Router Reachability Probing.
512         *
513         * Router Reachability Probe MUST be rate-limited
514         * to no more than one per minute.
515         */
516        if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
517                return;
518        rcu_read_lock_bh();
519        neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
520        if (neigh) {
521                write_lock(&neigh->lock);
522                if (neigh->nud_state & NUD_VALID)
523                        goto out;
524        }
525
526        if (!neigh ||
527            time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
528                struct __rt6_probe_work *work;
529
530                work = kmalloc(sizeof(*work), GFP_ATOMIC);
531
532                if (neigh && work)
533                        __neigh_set_probe_once(neigh);
534
535                if (neigh)
536                        write_unlock(&neigh->lock);
537
538                if (work) {
539                        INIT_WORK(&work->work, rt6_probe_deferred);
540                        work->target = rt->rt6i_gateway;
541                        dev_hold(rt->dst.dev);
542                        work->dev = rt->dst.dev;
543                        schedule_work(&work->work);
544                }
545        } else {
546out:
547                write_unlock(&neigh->lock);
548        }
549        rcu_read_unlock_bh();
550}
551#else
552static inline void rt6_probe(struct rt6_info *rt)
553{
554}
555#endif
556
557/*
558 * Default Router Selection (RFC 2461 6.3.6)
559 */
560static inline int rt6_check_dev(struct rt6_info *rt, int oif)
561{
562        struct net_device *dev = rt->dst.dev;
563        if (!oif || dev->ifindex == oif)
564                return 2;
565        if ((dev->flags & IFF_LOOPBACK) &&
566            rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
567                return 1;
568        return 0;
569}
570
571static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
572{
573        struct neighbour *neigh;
574        enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
575
576        if (rt->rt6i_flags & RTF_NONEXTHOP ||
577            !(rt->rt6i_flags & RTF_GATEWAY))
578                return RT6_NUD_SUCCEED;
579
580        rcu_read_lock_bh();
581        neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
582        if (neigh) {
583                read_lock(&neigh->lock);
584                if (neigh->nud_state & NUD_VALID)
585                        ret = RT6_NUD_SUCCEED;
586#ifdef CONFIG_IPV6_ROUTER_PREF
587                else if (!(neigh->nud_state & NUD_FAILED))
588                        ret = RT6_NUD_SUCCEED;
589                else
590                        ret = RT6_NUD_FAIL_PROBE;
591#endif
592                read_unlock(&neigh->lock);
593        } else {
594                ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
595                      RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
596        }
597        rcu_read_unlock_bh();
598
599        return ret;
600}
601
602static int rt6_score_route(struct rt6_info *rt, int oif,
603                           int strict)
604{
605        int m;
606
607        m = rt6_check_dev(rt, oif);
608        if (!m && (strict & RT6_LOOKUP_F_IFACE))
609                return RT6_NUD_FAIL_HARD;
610#ifdef CONFIG_IPV6_ROUTER_PREF
611        m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
612#endif
613        if (strict & RT6_LOOKUP_F_REACHABLE) {
614                int n = rt6_check_neigh(rt);
615                if (n < 0)
616                        return n;
617        }
618        return m;
619}
620
621static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
622                                   int *mpri, struct rt6_info *match,
623                                   bool *do_rr)
624{
625        int m;
626        bool match_do_rr = false;
627
628        if (rt6_check_expired(rt))
629                goto out;
630
631        m = rt6_score_route(rt, oif, strict);
632        if (m == RT6_NUD_FAIL_DO_RR) {
633                match_do_rr = true;
634                m = 0; /* lowest valid score */
635        } else if (m == RT6_NUD_FAIL_HARD) {
636                goto out;
637        }
638
639        if (strict & RT6_LOOKUP_F_REACHABLE)
640                rt6_probe(rt);
641
642        /* note that m can be RT6_NUD_FAIL_PROBE at this point */
643        if (m > *mpri) {
644                *do_rr = match_do_rr;
645                *mpri = m;
646                match = rt;
647        }
648out:
649        return match;
650}
651
652static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
653                                     struct rt6_info *rr_head,
654                                     u32 metric, int oif, int strict,
655                                     bool *do_rr)
656{
657        struct rt6_info *rt, *match;
658        int mpri = -1;
659
660        match = NULL;
661        for (rt = rr_head; rt && rt->rt6i_metric == metric;
662             rt = rt->dst.rt6_next)
663                match = find_match(rt, oif, strict, &mpri, match, do_rr);
664        for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
665             rt = rt->dst.rt6_next)
666                match = find_match(rt, oif, strict, &mpri, match, do_rr);
667
668        return match;
669}
670
671static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
672{
673        struct rt6_info *match, *rt0;
674        struct net *net;
675        bool do_rr = false;
676
677        rt0 = fn->rr_ptr;
678        if (!rt0)
679                fn->rr_ptr = rt0 = fn->leaf;
680
681        match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
682                             &do_rr);
683
684        if (do_rr) {
685                struct rt6_info *next = rt0->dst.rt6_next;
686
687                /* no entries matched; do round-robin */
688                if (!next || next->rt6i_metric != rt0->rt6i_metric)
689                        next = fn->leaf;
690
691                if (next != rt0)
692                        fn->rr_ptr = next;
693        }
694
695        net = dev_net(rt0->dst.dev);
696        return match ? match : net->ipv6.ip6_null_entry;
697}
698
699#ifdef CONFIG_IPV6_ROUTE_INFO
700int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
701                  const struct in6_addr *gwaddr)
702{
703        struct net *net = dev_net(dev);
704        struct route_info *rinfo = (struct route_info *) opt;
705        struct in6_addr prefix_buf, *prefix;
706        unsigned int pref;
707        unsigned long lifetime;
708        struct rt6_info *rt;
709
710        if (len < sizeof(struct route_info)) {
711                return -EINVAL;
712        }
713
714        /* Sanity check for prefix_len and length */
715        if (rinfo->length > 3) {
716                return -EINVAL;
717        } else if (rinfo->prefix_len > 128) {
718                return -EINVAL;
719        } else if (rinfo->prefix_len > 64) {
720                if (rinfo->length < 2) {
721                        return -EINVAL;
722                }
723        } else if (rinfo->prefix_len > 0) {
724                if (rinfo->length < 1) {
725                        return -EINVAL;
726                }
727        }
728
729        pref = rinfo->route_pref;
730        if (pref == ICMPV6_ROUTER_PREF_INVALID)
731                return -EINVAL;
732
733        lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
734
735        if (rinfo->length == 3)
736                prefix = (struct in6_addr *)rinfo->prefix;
737        else {
738                /* this function is safe */
739                ipv6_addr_prefix(&prefix_buf,
740                                 (struct in6_addr *)rinfo->prefix,
741                                 rinfo->prefix_len);
742                prefix = &prefix_buf;
743        }
744
745        if (rinfo->prefix_len == 0)
746                rt = rt6_get_dflt_router(gwaddr, dev);
747        else
748                rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
749                                        gwaddr, dev->ifindex);
750
751        if (rt && !lifetime) {
752                ip6_del_rt(rt);
753                rt = NULL;
754        }
755
756        if (!rt && lifetime)
757                rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
758                                        pref);
759        else if (rt)
760                rt->rt6i_flags = RTF_ROUTEINFO |
761                                 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
762
763        if (rt) {
764                if (!addrconf_finite_timeout(lifetime))
765                        rt6_clean_expires(rt);
766                else
767                        rt6_set_expires(rt, jiffies + HZ * lifetime);
768
769                ip6_rt_put(rt);
770        }
771        return 0;
772}
773#endif
774
775#define BACKTRACK(__net, saddr)                 \
776do { \
777        if (rt == __net->ipv6.ip6_null_entry) { \
778                struct fib6_node *pn; \
779                while (1) { \
780                        if (fn->fn_flags & RTN_TL_ROOT) \
781                                goto out; \
782                        pn = fn->parent; \
783                        if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
784                                fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
785                        else \
786                                fn = pn; \
787                        if (fn->fn_flags & RTN_RTINFO) \
788                                goto restart; \
789                } \
790        } \
791} while (0)
792
793static struct rt6_info *ip6_pol_route_lookup(struct net *net,
794                                             struct fib6_table *table,
795                                             struct flowi6 *fl6, int flags)
796{
797        struct fib6_node *fn;
798        struct rt6_info *rt;
799
800        read_lock_bh(&table->tb6_lock);
801        fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
802restart:
803        rt = fn->leaf;
804        rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
805        if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
806                rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
807        BACKTRACK(net, &fl6->saddr);
808out:
809        dst_use(&rt->dst, jiffies);
810        read_unlock_bh(&table->tb6_lock);
811        return rt;
812
813}
814
815struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
816                                    int flags)
817{
818        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
819}
820EXPORT_SYMBOL_GPL(ip6_route_lookup);
821
822struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
823                            const struct in6_addr *saddr, int oif, int strict)
824{
825        struct flowi6 fl6 = {
826                .flowi6_oif = oif,
827                .daddr = *daddr,
828        };
829        struct dst_entry *dst;
830        int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
831
832        if (saddr) {
833                memcpy(&fl6.saddr, saddr, sizeof(*saddr));
834                flags |= RT6_LOOKUP_F_HAS_SADDR;
835        }
836
837        dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
838        if (dst->error == 0)
839                return (struct rt6_info *) dst;
840
841        dst_release(dst);
842
843        return NULL;
844}
845EXPORT_SYMBOL(rt6_lookup);
846
847/* ip6_ins_rt is called with FREE table->tb6_lock.
848   It takes new route entry, the addition fails by any reason the
849   route is freed. In any case, if caller does not hold it, it may
850   be destroyed.
851 */
852
853static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
854                        struct nlattr *mx, int mx_len)
855{
856        int err;
857        struct fib6_table *table;
858
859        table = rt->rt6i_table;
860        write_lock_bh(&table->tb6_lock);
861        err = fib6_add(&table->tb6_root, rt, info, mx, mx_len);
862        write_unlock_bh(&table->tb6_lock);
863
864        return err;
865}
866
867int ip6_ins_rt(struct rt6_info *rt)
868{
869        struct nl_info info = {
870                .nl_net = dev_net(rt->dst.dev),
871        };
872        return __ip6_ins_rt(rt, &info, NULL, 0);
873}
874
875static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
876                                      const struct in6_addr *daddr,
877                                      const struct in6_addr *saddr)
878{
879        struct rt6_info *rt;
880
881        /*
882         *      Clone the route.
883         */
884
885        rt = ip6_rt_copy(ort, daddr);
886
887        if (rt) {
888                if (ort->rt6i_dst.plen != 128 &&
889                    ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
890                        rt->rt6i_flags |= RTF_ANYCAST;
891
892                rt->rt6i_flags |= RTF_CACHE;
893
894#ifdef CONFIG_IPV6_SUBTREES
895                if (rt->rt6i_src.plen && saddr) {
896                        rt->rt6i_src.addr = *saddr;
897                        rt->rt6i_src.plen = 128;
898                }
899#endif
900        }
901
902        return rt;
903}
904
905static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
906                                        const struct in6_addr *daddr)
907{
908        struct rt6_info *rt = ip6_rt_copy(ort, daddr);
909
910        if (rt)
911                rt->rt6i_flags |= RTF_CACHE;
912        return rt;
913}
914
915static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
916                                      struct flowi6 *fl6, int flags)
917{
918        struct fib6_node *fn;
919        struct rt6_info *rt, *nrt;
920        int strict = 0;
921        int attempts = 3;
922        int err;
923        int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
924
925        strict |= flags & RT6_LOOKUP_F_IFACE;
926
927relookup:
928        read_lock_bh(&table->tb6_lock);
929
930restart_2:
931        fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
932
933restart:
934        rt = rt6_select(fn, oif, strict | reachable);
935        if (rt->rt6i_nsiblings)
936                rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);
937        BACKTRACK(net, &fl6->saddr);
938        if (rt == net->ipv6.ip6_null_entry ||
939            rt->rt6i_flags & RTF_CACHE)
940                goto out;
941
942        dst_hold(&rt->dst);
943        read_unlock_bh(&table->tb6_lock);
944
945        if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))
946                nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
947        else if (!(rt->dst.flags & DST_HOST))
948                nrt = rt6_alloc_clone(rt, &fl6->daddr);
949        else
950                goto out2;
951
952        ip6_rt_put(rt);
953        rt = nrt ? : net->ipv6.ip6_null_entry;
954
955        dst_hold(&rt->dst);
956        if (nrt) {
957                err = ip6_ins_rt(nrt);
958                if (!err)
959                        goto out2;
960        }
961
962        if (--attempts <= 0)
963                goto out2;
964
965        /*
966         * Race condition! In the gap, when table->tb6_lock was
967         * released someone could insert this route.  Relookup.
968         */
969        ip6_rt_put(rt);
970        goto relookup;
971
972out:
973        if (reachable) {
974                reachable = 0;
975                goto restart_2;
976        }
977        dst_hold(&rt->dst);
978        read_unlock_bh(&table->tb6_lock);
979out2:
980        rt->dst.lastuse = jiffies;
981        rt->dst.__use++;
982
983        return rt;
984}
985
986static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
987                                            struct flowi6 *fl6, int flags)
988{
989        return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
990}
991
992static struct dst_entry *ip6_route_input_lookup(struct net *net,
993                                                struct net_device *dev,
994                                                struct flowi6 *fl6, int flags)
995{
996        if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
997                flags |= RT6_LOOKUP_F_IFACE;
998
999        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1000}
1001
1002void ip6_route_input(struct sk_buff *skb)
1003{
1004        const struct ipv6hdr *iph = ipv6_hdr(skb);
1005        struct net *net = dev_net(skb->dev);
1006        int flags = RT6_LOOKUP_F_HAS_SADDR;
1007        struct flowi6 fl6 = {
1008                .flowi6_iif = skb->dev->ifindex,
1009                .daddr = iph->daddr,
1010                .saddr = iph->saddr,
1011                .flowlabel = ip6_flowinfo(iph),
1012                .flowi6_mark = skb->mark,
1013                .flowi6_proto = iph->nexthdr,
1014        };
1015
1016        skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1017}
1018
1019static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1020                                             struct flowi6 *fl6, int flags)
1021{
1022        return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1023}
1024
1025struct dst_entry *ip6_route_output(struct net *net, const struct sock *sk,
1026                                    struct flowi6 *fl6)
1027{
1028        int flags = 0;
1029
1030        fl6->flowi6_iif = LOOPBACK_IFINDEX;
1031
1032        if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
1033                flags |= RT6_LOOKUP_F_IFACE;
1034
1035        if (!ipv6_addr_any(&fl6->saddr))
1036                flags |= RT6_LOOKUP_F_HAS_SADDR;
1037        else if (sk)
1038                flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1039
1040        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1041}
1042EXPORT_SYMBOL(ip6_route_output);
1043
1044struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1045{
1046        struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1047        struct dst_entry *new = NULL;
1048
1049        rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1050        if (rt) {
1051                new = &rt->dst;
1052
1053                memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
1054                rt6_init_peer(rt, net->ipv6.peers);
1055
1056                new->__use = 1;
1057                new->input = dst_discard;
1058                new->output = dst_discard_sk;
1059
1060                if (dst_metrics_read_only(&ort->dst))
1061                        new->_metrics = ort->dst._metrics;
1062                else
1063                        dst_copy_metrics(new, &ort->dst);
1064                rt->rt6i_idev = ort->rt6i_idev;
1065                if (rt->rt6i_idev)
1066                        in6_dev_hold(rt->rt6i_idev);
1067
1068                rt->rt6i_gateway = ort->rt6i_gateway;
1069                rt->rt6i_flags = ort->rt6i_flags;
1070                rt->rt6i_metric = 0;
1071
1072                memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1073#ifdef CONFIG_IPV6_SUBTREES
1074                memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1075#endif
1076
1077                dst_free(new);
1078        }
1079
1080        dst_release(dst_orig);
1081        return new ? new : ERR_PTR(-ENOMEM);
1082}
1083
1084/*
1085 *      Destination cache support functions
1086 */
1087
1088static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1089{
1090        struct rt6_info *rt;
1091
1092        rt = (struct rt6_info *) dst;
1093
1094        /* All IPV6 dsts are created with ->obsolete set to the value
1095         * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1096         * into this function always.
1097         */
1098        if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1099                return NULL;
1100
1101        if (rt6_check_expired(rt))
1102                return NULL;
1103
1104        return dst;
1105}
1106
1107static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1108{
1109        struct rt6_info *rt = (struct rt6_info *) dst;
1110
1111        if (rt) {
1112                if (rt->rt6i_flags & RTF_CACHE) {
1113                        if (rt6_check_expired(rt)) {
1114                                ip6_del_rt(rt);
1115                                dst = NULL;
1116                        }
1117                } else {
1118                        dst_release(dst);
1119                        dst = NULL;
1120                }
1121        }
1122        return dst;
1123}
1124
1125static void ip6_link_failure(struct sk_buff *skb)
1126{
1127        struct rt6_info *rt;
1128
1129        icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1130
1131        rt = (struct rt6_info *) skb_dst(skb);
1132        if (rt) {
1133                if (rt->rt6i_flags & RTF_CACHE) {
1134                        dst_hold(&rt->dst);
1135                        if (ip6_del_rt(rt))
1136                                dst_free(&rt->dst);
1137                } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1138                        rt->rt6i_node->fn_sernum = -1;
1139                }
1140        }
1141}
1142
1143static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1144                               struct sk_buff *skb, u32 mtu)
1145{
1146        struct rt6_info *rt6 = (struct rt6_info *)dst;
1147
1148        dst_confirm(dst);
1149        if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1150                struct net *net = dev_net(dst->dev);
1151
1152                rt6->rt6i_flags |= RTF_MODIFIED;
1153                if (mtu < IPV6_MIN_MTU)
1154                        mtu = IPV6_MIN_MTU;
1155
1156                dst_metric_set(dst, RTAX_MTU, mtu);
1157                rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1158        }
1159}
1160
1161void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1162                     int oif, u32 mark)
1163{
1164        const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1165        struct dst_entry *dst;
1166        struct flowi6 fl6;
1167
1168        memset(&fl6, 0, sizeof(fl6));
1169        fl6.flowi6_oif = oif;
1170        fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1171        fl6.daddr = iph->daddr;
1172        fl6.saddr = iph->saddr;
1173        fl6.flowlabel = ip6_flowinfo(iph);
1174
1175        dst = ip6_route_output(net, NULL, &fl6);
1176        if (!dst->error)
1177                ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1178        dst_release(dst);
1179}
1180EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1181
1182void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1183{
1184        ip6_update_pmtu(skb, sock_net(sk), mtu,
1185                        sk->sk_bound_dev_if, sk->sk_mark);
1186}
1187EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1188
1189/* Handle redirects */
1190struct ip6rd_flowi {
1191        struct flowi6 fl6;
1192        struct in6_addr gateway;
1193};
1194
1195static struct rt6_info *__ip6_route_redirect(struct net *net,
1196                                             struct fib6_table *table,
1197                                             struct flowi6 *fl6,
1198                                             int flags)
1199{
1200        struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1201        struct rt6_info *rt;
1202        struct fib6_node *fn;
1203
1204        /* Get the "current" route for this destination and
1205         * check if the redirect has come from approriate router.
1206         *
1207         * RFC 4861 specifies that redirects should only be
1208         * accepted if they come from the nexthop to the target.
1209         * Due to the way the routes are chosen, this notion
1210         * is a bit fuzzy and one might need to check all possible
1211         * routes.
1212         */
1213
1214        read_lock_bh(&table->tb6_lock);
1215        fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1216restart:
1217        for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1218                if (rt6_check_expired(rt))
1219                        continue;
1220                if (rt->dst.error)
1221                        break;
1222                if (!(rt->rt6i_flags & RTF_GATEWAY))
1223                        continue;
1224                if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1225                        continue;
1226                if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1227                        continue;
1228                break;
1229        }
1230
1231        if (!rt)
1232                rt = net->ipv6.ip6_null_entry;
1233        else if (rt->dst.error) {
1234                rt = net->ipv6.ip6_null_entry;
1235                goto out;
1236        }
1237        BACKTRACK(net, &fl6->saddr);
1238out:
1239        dst_hold(&rt->dst);
1240
1241        read_unlock_bh(&table->tb6_lock);
1242
1243        return rt;
1244};
1245
1246static struct dst_entry *ip6_route_redirect(struct net *net,
1247                                        const struct flowi6 *fl6,
1248                                        const struct in6_addr *gateway)
1249{
1250        int flags = RT6_LOOKUP_F_HAS_SADDR;
1251        struct ip6rd_flowi rdfl;
1252
1253        rdfl.fl6 = *fl6;
1254        rdfl.gateway = *gateway;
1255
1256        return fib6_rule_lookup(net, &rdfl.fl6,
1257                                flags, __ip6_route_redirect);
1258}
1259
1260void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1261{
1262        const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1263        struct dst_entry *dst;
1264        struct flowi6 fl6;
1265
1266        memset(&fl6, 0, sizeof(fl6));
1267        fl6.flowi6_iif = LOOPBACK_IFINDEX;
1268        fl6.flowi6_oif = oif;
1269        fl6.flowi6_mark = mark;
1270        fl6.daddr = iph->daddr;
1271        fl6.saddr = iph->saddr;
1272        fl6.flowlabel = ip6_flowinfo(iph);
1273
1274        dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1275        rt6_do_redirect(dst, NULL, skb);
1276        dst_release(dst);
1277}
1278EXPORT_SYMBOL_GPL(ip6_redirect);
1279
1280void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1281                            u32 mark)
1282{
1283        const struct ipv6hdr *iph = ipv6_hdr(skb);
1284        const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1285        struct dst_entry *dst;
1286        struct flowi6 fl6;
1287
1288        memset(&fl6, 0, sizeof(fl6));
1289        fl6.flowi6_iif = LOOPBACK_IFINDEX;
1290        fl6.flowi6_oif = oif;
1291        fl6.flowi6_mark = mark;
1292        fl6.daddr = msg->dest;
1293        fl6.saddr = iph->daddr;
1294
1295        dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1296        rt6_do_redirect(dst, NULL, skb);
1297        dst_release(dst);
1298}
1299
1300void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1301{
1302        ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1303}
1304EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1305
1306static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1307{
1308        struct net_device *dev = dst->dev;
1309        unsigned int mtu = dst_mtu(dst);
1310        struct net *net = dev_net(dev);
1311
1312        mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1313
1314        if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1315                mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1316
1317        /*
1318         * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1319         * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1320         * IPV6_MAXPLEN is also valid and means: "any MSS,
1321         * rely only on pmtu discovery"
1322         */
1323        if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1324                mtu = IPV6_MAXPLEN;
1325        return mtu;
1326}
1327
1328static unsigned int ip6_mtu(const struct dst_entry *dst)
1329{
1330        struct inet6_dev *idev;
1331        unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1332
1333        if (mtu)
1334                goto out;
1335
1336        mtu = IPV6_MIN_MTU;
1337
1338        rcu_read_lock();
1339        idev = __in6_dev_get(dst->dev);
1340        if (idev)
1341                mtu = idev->cnf.mtu6;
1342        rcu_read_unlock();
1343
1344out:
1345        return min_t(unsigned int, mtu, IP6_MAX_MTU);
1346}
1347
1348static struct dst_entry *icmp6_dst_gc_list;
1349static DEFINE_SPINLOCK(icmp6_dst_lock);
1350
1351struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1352                                  struct flowi6 *fl6)
1353{
1354        struct dst_entry *dst;
1355        struct rt6_info *rt;
1356        struct inet6_dev *idev = in6_dev_get(dev);
1357        struct net *net = dev_net(dev);
1358
1359        if (unlikely(!idev))
1360                return ERR_PTR(-ENODEV);
1361
1362        rt = ip6_dst_alloc(net, dev, 0, NULL);
1363        if (unlikely(!rt)) {
1364                in6_dev_put(idev);
1365                dst = ERR_PTR(-ENOMEM);
1366                goto out;
1367        }
1368
1369        rt->dst.flags |= DST_HOST;
1370        rt->dst.output  = ip6_output;
1371        atomic_set(&rt->dst.__refcnt, 1);
1372        rt->rt6i_gateway  = fl6->daddr;
1373        rt->rt6i_dst.addr = fl6->daddr;
1374        rt->rt6i_dst.plen = 128;
1375        rt->rt6i_idev     = idev;
1376        dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1377
1378        spin_lock_bh(&icmp6_dst_lock);
1379        rt->dst.next = icmp6_dst_gc_list;
1380        icmp6_dst_gc_list = &rt->dst;
1381        spin_unlock_bh(&icmp6_dst_lock);
1382
1383        fib6_force_start_gc(net);
1384
1385        dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1386
1387out:
1388        return dst;
1389}
1390
1391int icmp6_dst_gc(void)
1392{
1393        struct dst_entry *dst, **pprev;
1394        int more = 0;
1395
1396        spin_lock_bh(&icmp6_dst_lock);
1397        pprev = &icmp6_dst_gc_list;
1398
1399        while ((dst = *pprev) != NULL) {
1400                if (!atomic_read(&dst->__refcnt)) {
1401                        *pprev = dst->next;
1402                        dst_free(dst);
1403                } else {
1404                        pprev = &dst->next;
1405                        ++more;
1406                }
1407        }
1408
1409        spin_unlock_bh(&icmp6_dst_lock);
1410
1411        return more;
1412}
1413
1414static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1415                            void *arg)
1416{
1417        struct dst_entry *dst, **pprev;
1418
1419        spin_lock_bh(&icmp6_dst_lock);
1420        pprev = &icmp6_dst_gc_list;
1421        while ((dst = *pprev) != NULL) {
1422                struct rt6_info *rt = (struct rt6_info *) dst;
1423                if (func(rt, arg)) {
1424                        *pprev = dst->next;
1425                        dst_free(dst);
1426                } else {
1427                        pprev = &dst->next;
1428                }
1429        }
1430        spin_unlock_bh(&icmp6_dst_lock);
1431}
1432
1433static int ip6_dst_gc(struct dst_ops *ops)
1434{
1435        struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1436        int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1437        int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1438        int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1439        int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1440        unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1441        int entries;
1442
1443        entries = dst_entries_get_fast(ops);
1444        if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1445            entries <= rt_max_size)
1446                goto out;
1447
1448        net->ipv6.ip6_rt_gc_expire++;
1449        fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1450        entries = dst_entries_get_slow(ops);
1451        if (entries < ops->gc_thresh)
1452                net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1453out:
1454        net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1455        return entries > rt_max_size;
1456}
1457
1458/*
1459 *
1460 */
1461
1462int ip6_route_add(struct fib6_config *cfg)
1463{
1464        int err;
1465        struct net *net = cfg->fc_nlinfo.nl_net;
1466        struct rt6_info *rt = NULL;
1467        struct net_device *dev = NULL;
1468        struct inet6_dev *idev = NULL;
1469        struct fib6_table *table;
1470        int addr_type;
1471
1472        if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1473                return -EINVAL;
1474#ifndef CONFIG_IPV6_SUBTREES
1475        if (cfg->fc_src_len)
1476                return -EINVAL;
1477#endif
1478        if (cfg->fc_ifindex) {
1479                err = -ENODEV;
1480                dev = dev_get_by_index(net, cfg->fc_ifindex);
1481                if (!dev)
1482                        goto out;
1483                idev = in6_dev_get(dev);
1484                if (!idev)
1485                        goto out;
1486        }
1487
1488        if (cfg->fc_metric == 0)
1489                cfg->fc_metric = IP6_RT_PRIO_USER;
1490
1491        err = -ENOBUFS;
1492        if (cfg->fc_nlinfo.nlh &&
1493            !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1494                table = fib6_get_table(net, cfg->fc_table);
1495                if (!table) {
1496                        pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1497                        table = fib6_new_table(net, cfg->fc_table);
1498                }
1499        } else {
1500                table = fib6_new_table(net, cfg->fc_table);
1501        }
1502
1503        if (!table)
1504                goto out;
1505
1506        rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);
1507
1508        if (!rt) {
1509                err = -ENOMEM;
1510                goto out;
1511        }
1512
1513        if (cfg->fc_flags & RTF_EXPIRES)
1514                rt6_set_expires(rt, jiffies +
1515                                clock_t_to_jiffies(cfg->fc_expires));
1516        else
1517                rt6_clean_expires(rt);
1518
1519        if (cfg->fc_protocol == RTPROT_UNSPEC)
1520                cfg->fc_protocol = RTPROT_BOOT;
1521        rt->rt6i_protocol = cfg->fc_protocol;
1522
1523        addr_type = ipv6_addr_type(&cfg->fc_dst);
1524
1525        if (addr_type & IPV6_ADDR_MULTICAST)
1526                rt->dst.input = ip6_mc_input;
1527        else if (cfg->fc_flags & RTF_LOCAL)
1528                rt->dst.input = ip6_input;
1529        else
1530                rt->dst.input = ip6_forward;
1531
1532        rt->dst.output = ip6_output;
1533
1534        ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1535        rt->rt6i_dst.plen = cfg->fc_dst_len;
1536        if (rt->rt6i_dst.plen == 128) {
1537                rt->dst.flags |= DST_HOST;
1538                dst_metrics_set_force_overwrite(&rt->dst);
1539        }
1540
1541#ifdef CONFIG_IPV6_SUBTREES
1542        ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1543        rt->rt6i_src.plen = cfg->fc_src_len;
1544#endif
1545
1546        rt->rt6i_metric = cfg->fc_metric;
1547
1548        /* We cannot add true routes via loopback here,
1549           they would result in kernel looping; promote them to reject routes
1550         */
1551        if ((cfg->fc_flags & RTF_REJECT) ||
1552            (dev && (dev->flags & IFF_LOOPBACK) &&
1553             !(addr_type & IPV6_ADDR_LOOPBACK) &&
1554             !(cfg->fc_flags & RTF_LOCAL))) {
1555                /* hold loopback dev/idev if we haven't done so. */
1556                if (dev != net->loopback_dev) {
1557                        if (dev) {
1558                                dev_put(dev);
1559                                in6_dev_put(idev);
1560                        }
1561                        dev = net->loopback_dev;
1562                        dev_hold(dev);
1563                        idev = in6_dev_get(dev);
1564                        if (!idev) {
1565                                err = -ENODEV;
1566                                goto out;
1567                        }
1568                }
1569                rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1570                switch (cfg->fc_type) {
1571                case RTN_BLACKHOLE:
1572                        rt->dst.error = -EINVAL;
1573                        rt->dst.output = dst_discard_sk;
1574                        rt->dst.input = dst_discard;
1575                        break;
1576                case RTN_PROHIBIT:
1577                        rt->dst.error = -EACCES;
1578                        rt->dst.output = ip6_pkt_prohibit_out;
1579                        rt->dst.input = ip6_pkt_prohibit;
1580                        break;
1581                case RTN_THROW:
1582                default:
1583                        rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1584                                        : -ENETUNREACH;
1585                        rt->dst.output = ip6_pkt_discard_out;
1586                        rt->dst.input = ip6_pkt_discard;
1587                        break;
1588                }
1589                goto install_route;
1590        }
1591
1592        if (cfg->fc_flags & RTF_GATEWAY) {
1593                const struct in6_addr *gw_addr;
1594                int gwa_type;
1595
1596                gw_addr = &cfg->fc_gateway;
1597                rt->rt6i_gateway = *gw_addr;
1598                gwa_type = ipv6_addr_type(gw_addr);
1599
1600                if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1601                        struct rt6_info *grt;
1602
1603                        /* IPv6 strictly inhibits using not link-local
1604                           addresses as nexthop address.
1605                           Otherwise, router will not able to send redirects.
1606                           It is very good, but in some (rare!) circumstances
1607                           (SIT, PtP, NBMA NOARP links) it is handy to allow
1608                           some exceptions. --ANK
1609                         */
1610                        err = -EINVAL;
1611                        if (!(gwa_type & IPV6_ADDR_UNICAST))
1612                                goto out;
1613
1614                        grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1615
1616                        err = -EHOSTUNREACH;
1617                        if (!grt)
1618                                goto out;
1619                        if (dev) {
1620                                if (dev != grt->dst.dev) {
1621                                        ip6_rt_put(grt);
1622                                        goto out;
1623                                }
1624                        } else {
1625                                dev = grt->dst.dev;
1626                                idev = grt->rt6i_idev;
1627                                dev_hold(dev);
1628                                in6_dev_hold(grt->rt6i_idev);
1629                        }
1630                        if (!(grt->rt6i_flags & RTF_GATEWAY))
1631                                err = 0;
1632                        ip6_rt_put(grt);
1633
1634                        if (err)
1635                                goto out;
1636                }
1637                err = -EINVAL;
1638                if (!dev || (dev->flags & IFF_LOOPBACK))
1639                        goto out;
1640        }
1641
1642        err = -ENODEV;
1643        if (!dev)
1644                goto out;
1645
1646        if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1647                if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1648                        err = -EINVAL;
1649                        goto out;
1650                }
1651                rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1652                rt->rt6i_prefsrc.plen = 128;
1653        } else
1654                rt->rt6i_prefsrc.plen = 0;
1655
1656        rt->rt6i_flags = cfg->fc_flags;
1657
1658install_route:
1659        rt->dst.dev = dev;
1660        rt->rt6i_idev = idev;
1661        rt->rt6i_table = table;
1662
1663        cfg->fc_nlinfo.nl_net = dev_net(dev);
1664
1665        return __ip6_ins_rt(rt, &cfg->fc_nlinfo, cfg->fc_mx, cfg->fc_mx_len);
1666
1667out:
1668        if (dev)
1669                dev_put(dev);
1670        if (idev)
1671                in6_dev_put(idev);
1672        if (rt)
1673                dst_free(&rt->dst);
1674        return err;
1675}
1676
1677static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1678{
1679        int err;
1680        struct fib6_table *table;
1681        struct net *net = dev_net(rt->dst.dev);
1682
1683        if (rt == net->ipv6.ip6_null_entry) {
1684                err = -ENOENT;
1685                goto out;
1686        }
1687
1688        table = rt->rt6i_table;
1689        write_lock_bh(&table->tb6_lock);
1690        err = fib6_del(rt, info);
1691        write_unlock_bh(&table->tb6_lock);
1692
1693out:
1694        ip6_rt_put(rt);
1695        return err;
1696}
1697
1698int ip6_del_rt(struct rt6_info *rt)
1699{
1700        struct nl_info info = {
1701                .nl_net = dev_net(rt->dst.dev),
1702        };
1703        return __ip6_del_rt(rt, &info);
1704}
1705
1706static int ip6_route_del(struct fib6_config *cfg)
1707{
1708        struct fib6_table *table;
1709        struct fib6_node *fn;
1710        struct rt6_info *rt;
1711        int err = -ESRCH;
1712
1713        table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1714        if (!table)
1715                return err;
1716
1717        read_lock_bh(&table->tb6_lock);
1718
1719        fn = fib6_locate(&table->tb6_root,
1720                         &cfg->fc_dst, cfg->fc_dst_len,
1721                         &cfg->fc_src, cfg->fc_src_len);
1722
1723        if (fn) {
1724                for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1725                        if (cfg->fc_ifindex &&
1726                            (!rt->dst.dev ||
1727                             rt->dst.dev->ifindex != cfg->fc_ifindex))
1728                                continue;
1729                        if (cfg->fc_flags & RTF_GATEWAY &&
1730                            !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1731                                continue;
1732                        if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1733                                continue;
1734                        dst_hold(&rt->dst);
1735                        read_unlock_bh(&table->tb6_lock);
1736
1737                        return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1738                }
1739        }
1740        read_unlock_bh(&table->tb6_lock);
1741
1742        return err;
1743}
1744
1745static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1746{
1747        struct net *net = dev_net(skb->dev);
1748        struct netevent_redirect netevent;
1749        struct rt6_info *rt, *nrt = NULL;
1750        struct ndisc_options ndopts;
1751        struct inet6_dev *in6_dev;
1752        struct neighbour *neigh;
1753        struct rd_msg *msg;
1754        int optlen, on_link;
1755        u8 *lladdr;
1756
1757        optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
1758        optlen -= sizeof(*msg);
1759
1760        if (optlen < 0) {
1761                net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1762                return;
1763        }
1764
1765        msg = (struct rd_msg *)icmp6_hdr(skb);
1766
1767        if (ipv6_addr_is_multicast(&msg->dest)) {
1768                net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1769                return;
1770        }
1771
1772        on_link = 0;
1773        if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1774                on_link = 1;
1775        } else if (ipv6_addr_type(&msg->target) !=
1776                   (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1777                net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1778                return;
1779        }
1780
1781        in6_dev = __in6_dev_get(skb->dev);
1782        if (!in6_dev)
1783                return;
1784        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1785                return;
1786
1787        /* RFC2461 8.1:
1788         *      The IP source address of the Redirect MUST be the same as the current
1789         *      first-hop router for the specified ICMP Destination Address.
1790         */
1791
1792        if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1793                net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1794                return;
1795        }
1796
1797        lladdr = NULL;
1798        if (ndopts.nd_opts_tgt_lladdr) {
1799                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1800                                             skb->dev);
1801                if (!lladdr) {
1802                        net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1803                        return;
1804                }
1805        }
1806
1807        rt = (struct rt6_info *) dst;
1808        if (rt == net->ipv6.ip6_null_entry) {
1809                net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1810                return;
1811        }
1812
1813        /* Redirect received -> path was valid.
1814         * Look, redirects are sent only in response to data packets,
1815         * so that this nexthop apparently is reachable. --ANK
1816         */
1817        dst_confirm(&rt->dst);
1818
1819        neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1820        if (!neigh)
1821                return;
1822
1823        /*
1824         *      We have finally decided to accept it.
1825         */
1826
1827        neigh_update(neigh, lladdr, NUD_STALE,
1828                     NEIGH_UPDATE_F_WEAK_OVERRIDE|
1829                     NEIGH_UPDATE_F_OVERRIDE|
1830                     (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1831                                     NEIGH_UPDATE_F_ISROUTER))
1832                     );
1833
1834        nrt = ip6_rt_copy(rt, &msg->dest);
1835        if (!nrt)
1836                goto out;
1837
1838        nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1839        if (on_link)
1840                nrt->rt6i_flags &= ~RTF_GATEWAY;
1841
1842        nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1843
1844        if (ip6_ins_rt(nrt))
1845                goto out;
1846
1847        netevent.old = &rt->dst;
1848        netevent.new = &nrt->dst;
1849        netevent.daddr = &msg->dest;
1850        netevent.neigh = neigh;
1851        call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1852
1853        if (rt->rt6i_flags & RTF_CACHE) {
1854                rt = (struct rt6_info *) dst_clone(&rt->dst);
1855                ip6_del_rt(rt);
1856        }
1857
1858out:
1859        neigh_release(neigh);
1860}
1861
1862/*
1863 *      Misc support functions
1864 */
1865
1866static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1867                                    const struct in6_addr *dest)
1868{
1869        struct net *net = dev_net(ort->dst.dev);
1870        struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1871                                            ort->rt6i_table);
1872
1873        if (rt) {
1874                rt->dst.input = ort->dst.input;
1875                rt->dst.output = ort->dst.output;
1876                rt->dst.flags |= DST_HOST;
1877
1878                rt->rt6i_dst.addr = *dest;
1879                rt->rt6i_dst.plen = 128;
1880                dst_copy_metrics(&rt->dst, &ort->dst);
1881                rt->dst.error = ort->dst.error;
1882                rt->rt6i_idev = ort->rt6i_idev;
1883                if (rt->rt6i_idev)
1884                        in6_dev_hold(rt->rt6i_idev);
1885                rt->dst.lastuse = jiffies;
1886
1887                if (ort->rt6i_flags & RTF_GATEWAY)
1888                        rt->rt6i_gateway = ort->rt6i_gateway;
1889                else
1890                        rt->rt6i_gateway = *dest;
1891                rt->rt6i_flags = ort->rt6i_flags;
1892                rt6_set_from(rt, ort);
1893                rt->rt6i_metric = 0;
1894
1895#ifdef CONFIG_IPV6_SUBTREES
1896                memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1897#endif
1898                memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1899                rt->rt6i_table = ort->rt6i_table;
1900        }
1901        return rt;
1902}
1903
1904#ifdef CONFIG_IPV6_ROUTE_INFO
1905static struct rt6_info *rt6_get_route_info(struct net *net,
1906                                           const struct in6_addr *prefix, int prefixlen,
1907                                           const struct in6_addr *gwaddr, int ifindex)
1908{
1909        struct fib6_node *fn;
1910        struct rt6_info *rt = NULL;
1911        struct fib6_table *table;
1912
1913        table = fib6_get_table(net, RT6_TABLE_INFO);
1914        if (!table)
1915                return NULL;
1916
1917        read_lock_bh(&table->tb6_lock);
1918        fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
1919        if (!fn)
1920                goto out;
1921
1922        for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1923                if (rt->dst.dev->ifindex != ifindex)
1924                        continue;
1925                if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1926                        continue;
1927                if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1928                        continue;
1929                dst_hold(&rt->dst);
1930                break;
1931        }
1932out:
1933        read_unlock_bh(&table->tb6_lock);
1934        return rt;
1935}
1936
1937static struct rt6_info *rt6_add_route_info(struct net *net,
1938                                           const struct in6_addr *prefix, int prefixlen,
1939                                           const struct in6_addr *gwaddr, int ifindex,
1940                                           unsigned int pref)
1941{
1942        struct fib6_config cfg = {
1943                .fc_table       = RT6_TABLE_INFO,
1944                .fc_metric      = IP6_RT_PRIO_USER,
1945                .fc_ifindex     = ifindex,
1946                .fc_dst_len     = prefixlen,
1947                .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1948                                  RTF_UP | RTF_PREF(pref),
1949                .fc_nlinfo.portid = 0,
1950                .fc_nlinfo.nlh = NULL,
1951                .fc_nlinfo.nl_net = net,
1952        };
1953
1954        cfg.fc_dst = *prefix;
1955        cfg.fc_gateway = *gwaddr;
1956
1957        /* We should treat it as a default route if prefix length is 0. */
1958        if (!prefixlen)
1959                cfg.fc_flags |= RTF_DEFAULT;
1960
1961        ip6_route_add(&cfg);
1962
1963        return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1964}
1965#endif
1966
1967struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1968{
1969        struct rt6_info *rt;
1970        struct fib6_table *table;
1971
1972        table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1973        if (!table)
1974                return NULL;
1975
1976        read_lock_bh(&table->tb6_lock);
1977        for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1978                if (dev == rt->dst.dev &&
1979                    ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1980                    ipv6_addr_equal(&rt->rt6i_gateway, addr))
1981                        break;
1982        }
1983        if (rt)
1984                dst_hold(&rt->dst);
1985        read_unlock_bh(&table->tb6_lock);
1986        return rt;
1987}
1988
1989struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1990                                     struct net_device *dev,
1991                                     unsigned int pref)
1992{
1993        struct fib6_config cfg = {
1994                .fc_table       = RT6_TABLE_DFLT,
1995                .fc_metric      = IP6_RT_PRIO_USER,
1996                .fc_ifindex     = dev->ifindex,
1997                .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1998                                  RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1999                .fc_nlinfo.portid = 0,
2000                .fc_nlinfo.nlh = NULL,
2001                .fc_nlinfo.nl_net = dev_net(dev),
2002        };
2003
2004        cfg.fc_gateway = *gwaddr;
2005
2006        ip6_route_add(&cfg);
2007
2008        return rt6_get_dflt_router(gwaddr, dev);
2009}
2010
2011void rt6_purge_dflt_routers(struct net *net)
2012{
2013        struct rt6_info *rt;
2014        struct fib6_table *table;
2015
2016        /* NOTE: Keep consistent with rt6_get_dflt_router */
2017        table = fib6_get_table(net, RT6_TABLE_DFLT);
2018        if (!table)
2019                return;
2020
2021restart:
2022        read_lock_bh(&table->tb6_lock);
2023        for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2024                if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2025                    (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2026                        dst_hold(&rt->dst);
2027                        read_unlock_bh(&table->tb6_lock);
2028                        ip6_del_rt(rt);
2029                        goto restart;
2030                }
2031        }
2032        read_unlock_bh(&table->tb6_lock);
2033}
2034
2035static void rtmsg_to_fib6_config(struct net *net,
2036                                 struct in6_rtmsg *rtmsg,
2037                                 struct fib6_config *cfg)
2038{
2039        memset(cfg, 0, sizeof(*cfg));
2040
2041        cfg->fc_table = RT6_TABLE_MAIN;
2042        cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2043        cfg->fc_metric = rtmsg->rtmsg_metric;
2044        cfg->fc_expires = rtmsg->rtmsg_info;
2045        cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2046        cfg->fc_src_len = rtmsg->rtmsg_src_len;
2047        cfg->fc_flags = rtmsg->rtmsg_flags;
2048
2049        cfg->fc_nlinfo.nl_net = net;
2050
2051        cfg->fc_dst = rtmsg->rtmsg_dst;
2052        cfg->fc_src = rtmsg->rtmsg_src;
2053        cfg->fc_gateway = rtmsg->rtmsg_gateway;
2054}
2055
2056int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2057{
2058        struct fib6_config cfg;
2059        struct in6_rtmsg rtmsg;
2060        int err;
2061
2062        switch (cmd) {
2063        case SIOCADDRT:         /* Add a route */
2064        case SIOCDELRT:         /* Delete a route */
2065                if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2066                        return -EPERM;
2067                err = copy_from_user(&rtmsg, arg,
2068                                     sizeof(struct in6_rtmsg));
2069                if (err)
2070                        return -EFAULT;
2071
2072                rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2073
2074                rtnl_lock();
2075                switch (cmd) {
2076                case SIOCADDRT:
2077                        err = ip6_route_add(&cfg);
2078                        break;
2079                case SIOCDELRT:
2080                        err = ip6_route_del(&cfg);
2081                        break;
2082                default:
2083                        err = -EINVAL;
2084                }
2085                rtnl_unlock();
2086
2087                return err;
2088        }
2089
2090        return -EINVAL;
2091}
2092
2093/*
2094 *      Drop the packet on the floor
2095 */
2096
2097static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2098{
2099        int type;
2100        struct dst_entry *dst = skb_dst(skb);
2101        switch (ipstats_mib_noroutes) {
2102        case IPSTATS_MIB_INNOROUTES:
2103                type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2104                if (type == IPV6_ADDR_ANY) {
2105                        IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2106                                      IPSTATS_MIB_INADDRERRORS);
2107                        break;
2108                }
2109                /* FALLTHROUGH */
2110        case IPSTATS_MIB_OUTNOROUTES:
2111                IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2112                              ipstats_mib_noroutes);
2113                break;
2114        }
2115        icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2116        kfree_skb(skb);
2117        return 0;
2118}
2119
2120static int ip6_pkt_discard(struct sk_buff *skb)
2121{
2122        return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2123}
2124
2125static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
2126{
2127        skb->dev = skb_dst(skb)->dev;
2128        return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2129}
2130
2131static int ip6_pkt_prohibit(struct sk_buff *skb)
2132{
2133        return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2134}
2135
2136static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
2137{
2138        skb->dev = skb_dst(skb)->dev;
2139        return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2140}
2141
2142/*
2143 *      Allocate a dst for local (unicast / anycast) address.
2144 */
2145
2146struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2147                                    const struct in6_addr *addr,
2148                                    bool anycast)
2149{
2150        struct net *net = dev_net(idev->dev);
2151        struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2152                                            DST_NOCOUNT, NULL);
2153        if (!rt)
2154                return ERR_PTR(-ENOMEM);
2155
2156        in6_dev_hold(idev);
2157
2158        rt->dst.flags |= DST_HOST;
2159        rt->dst.input = ip6_input;
2160        rt->dst.output = ip6_output;
2161        rt->rt6i_idev = idev;
2162
2163        rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2164        if (anycast)
2165                rt->rt6i_flags |= RTF_ANYCAST;
2166        else
2167                rt->rt6i_flags |= RTF_LOCAL;
2168
2169        rt->rt6i_gateway  = *addr;
2170        rt->rt6i_dst.addr = *addr;
2171        rt->rt6i_dst.plen = 128;
2172        rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2173
2174        atomic_set(&rt->dst.__refcnt, 1);
2175
2176        return rt;
2177}
2178
2179int ip6_route_get_saddr(struct net *net,
2180                        struct rt6_info *rt,
2181                        const struct in6_addr *daddr,
2182                        unsigned int prefs,
2183                        struct in6_addr *saddr)
2184{
2185        struct inet6_dev *idev = ip6_dst_idev((struct dst_entry *)rt);
2186        int err = 0;
2187        if (rt->rt6i_prefsrc.plen)
2188                *saddr = rt->rt6i_prefsrc.addr;
2189        else
2190                err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2191                                         daddr, prefs, saddr);
2192        return err;
2193}
2194
2195/* remove deleted ip from prefsrc entries */
2196struct arg_dev_net_ip {
2197        struct net_device *dev;
2198        struct net *net;
2199        struct in6_addr *addr;
2200};
2201
2202static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2203{
2204        struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2205        struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2206        struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2207
2208        if (((void *)rt->dst.dev == dev || !dev) &&
2209            rt != net->ipv6.ip6_null_entry &&
2210            ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2211                /* remove prefsrc entry */
2212                rt->rt6i_prefsrc.plen = 0;
2213        }
2214        return 0;
2215}
2216
2217void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2218{
2219        struct net *net = dev_net(ifp->idev->dev);
2220        struct arg_dev_net_ip adni = {
2221                .dev = ifp->idev->dev,
2222                .net = net,
2223                .addr = &ifp->addr,
2224        };
2225        fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2226}
2227
2228#define RTF_RA_ROUTER           (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2229#define RTF_CACHE_GATEWAY       (RTF_GATEWAY | RTF_CACHE)
2230
2231/* Remove routers and update dst entries when gateway turn into host. */
2232static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2233{
2234        struct in6_addr *gateway = (struct in6_addr *)arg;
2235
2236        if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2237             ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2238             ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2239                return -1;
2240        }
2241        return 0;
2242}
2243
2244void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2245{
2246        fib6_clean_all(net, fib6_clean_tohost, gateway);
2247}
2248
2249struct arg_dev_net {
2250        struct net_device *dev;
2251        struct net *net;
2252};
2253
2254static int fib6_ifdown(struct rt6_info *rt, void *arg)
2255{
2256        const struct arg_dev_net *adn = arg;
2257        const struct net_device *dev = adn->dev;
2258
2259        if ((rt->dst.dev == dev || !dev) &&
2260            rt != adn->net->ipv6.ip6_null_entry)
2261                return -1;
2262
2263        return 0;
2264}
2265
2266void rt6_ifdown(struct net *net, struct net_device *dev)
2267{
2268        struct arg_dev_net adn = {
2269                .dev = dev,
2270                .net = net,
2271        };
2272
2273        fib6_clean_all(net, fib6_ifdown, &adn);
2274        icmp6_clean_all(fib6_ifdown, &adn);
2275}
2276
2277struct rt6_mtu_change_arg {
2278        struct net_device *dev;
2279        unsigned int mtu;
2280};
2281
2282static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2283{
2284        struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2285        struct inet6_dev *idev;
2286
2287        /* In IPv6 pmtu discovery is not optional,
2288           so that RTAX_MTU lock cannot disable it.
2289           We still use this lock to block changes
2290           caused by addrconf/ndisc.
2291        */
2292
2293        idev = __in6_dev_get(arg->dev);
2294        if (!idev)
2295                return 0;
2296
2297        /* For administrative MTU increase, there is no way to discover
2298           IPv6 PMTU increase, so PMTU increase should be updated here.
2299           Since RFC 1981 doesn't include administrative MTU increase
2300           update PMTU increase is a MUST. (i.e. jumbo frame)
2301         */
2302        /*
2303           If new MTU is less than route PMTU, this new MTU will be the
2304           lowest MTU in the path, update the route PMTU to reflect PMTU
2305           decreases; if new MTU is greater than route PMTU, and the
2306           old MTU is the lowest MTU in the path, update the route PMTU
2307           to reflect the increase. In this case if the other nodes' MTU
2308           also have the lowest MTU, TOO BIG MESSAGE will be lead to
2309           PMTU discouvery.
2310         */
2311        if (rt->dst.dev == arg->dev &&
2312            !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2313            (dst_mtu(&rt->dst) >= arg->mtu ||
2314             (dst_mtu(&rt->dst) < arg->mtu &&
2315              dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2316                dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2317        }
2318        return 0;
2319}
2320
2321void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2322{
2323        struct rt6_mtu_change_arg arg = {
2324                .dev = dev,
2325                .mtu = mtu,
2326        };
2327
2328        fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2329}
2330
2331static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2332        [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
2333        [RTA_OIF]               = { .type = NLA_U32 },
2334        [RTA_IIF]               = { .type = NLA_U32 },
2335        [RTA_PRIORITY]          = { .type = NLA_U32 },
2336        [RTA_METRICS]           = { .type = NLA_NESTED },
2337        [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
2338};
2339
2340static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2341                              struct fib6_config *cfg)
2342{
2343        struct rtmsg *rtm;
2344        struct nlattr *tb[RTA_MAX+1];
2345        int err;
2346
2347        err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2348        if (err < 0)
2349                goto errout;
2350
2351        err = -EINVAL;
2352        rtm = nlmsg_data(nlh);
2353        memset(cfg, 0, sizeof(*cfg));
2354
2355        cfg->fc_table = rtm->rtm_table;
2356        cfg->fc_dst_len = rtm->rtm_dst_len;
2357        cfg->fc_src_len = rtm->rtm_src_len;
2358        cfg->fc_flags = RTF_UP;
2359        cfg->fc_protocol = rtm->rtm_protocol;
2360        cfg->fc_type = rtm->rtm_type;
2361
2362        if (rtm->rtm_type == RTN_UNREACHABLE ||
2363            rtm->rtm_type == RTN_BLACKHOLE ||
2364            rtm->rtm_type == RTN_PROHIBIT ||
2365            rtm->rtm_type == RTN_THROW)
2366                cfg->fc_flags |= RTF_REJECT;
2367
2368        if (rtm->rtm_type == RTN_LOCAL)
2369                cfg->fc_flags |= RTF_LOCAL;
2370
2371        cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2372        cfg->fc_nlinfo.nlh = nlh;
2373        cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2374
2375        if (tb[RTA_GATEWAY]) {
2376                nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2377                cfg->fc_flags |= RTF_GATEWAY;
2378        }
2379
2380        if (tb[RTA_DST]) {
2381                int plen = (rtm->rtm_dst_len + 7) >> 3;
2382
2383                if (nla_len(tb[RTA_DST]) < plen)
2384                        goto errout;
2385
2386                nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2387        }
2388
2389        if (tb[RTA_SRC]) {
2390                int plen = (rtm->rtm_src_len + 7) >> 3;
2391
2392                if (nla_len(tb[RTA_SRC]) < plen)
2393                        goto errout;
2394
2395                nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2396        }
2397
2398        if (tb[RTA_PREFSRC])
2399                nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2400
2401        if (tb[RTA_OIF])
2402                cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2403
2404        if (tb[RTA_PRIORITY])
2405                cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2406
2407        if (tb[RTA_METRICS]) {
2408                cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2409                cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2410        }
2411
2412        if (tb[RTA_TABLE])
2413                cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2414
2415        if (tb[RTA_MULTIPATH]) {
2416                cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2417                cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2418        }
2419
2420        err = 0;
2421errout:
2422        return err;
2423}
2424
2425static int ip6_route_multipath(struct fib6_config *cfg, int add)
2426{
2427        struct fib6_config r_cfg;
2428        struct rtnexthop *rtnh;
2429        int remaining;
2430        int attrlen;
2431        int err = 0, last_err = 0;
2432
2433beginning:
2434        rtnh = (struct rtnexthop *)cfg->fc_mp;
2435        remaining = cfg->fc_mp_len;
2436
2437        /* Parse a Multipath Entry */
2438        while (rtnh_ok(rtnh, remaining)) {
2439                memcpy(&r_cfg, cfg, sizeof(*cfg));
2440                if (rtnh->rtnh_ifindex)
2441                        r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2442
2443                attrlen = rtnh_attrlen(rtnh);
2444                if (attrlen > 0) {
2445                        struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2446
2447                        nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2448                        if (nla) {
2449                                nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2450                                r_cfg.fc_flags |= RTF_GATEWAY;
2451                        }
2452                }
2453                err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2454                if (err) {
2455                        last_err = err;
2456                        /* If we are trying to remove a route, do not stop the
2457                         * loop when ip6_route_del() fails (because next hop is
2458                         * already gone), we should try to remove all next hops.
2459                         */
2460                        if (add) {
2461                                /* If add fails, we should try to delete all
2462                                 * next hops that have been already added.
2463                                 */
2464                                add = 0;
2465                                goto beginning;
2466                        }
2467                }
2468                /* Because each route is added like a single route we remove
2469                 * this flag after the first nexthop (if there is a collision,
2470                 * we have already fail to add the first nexthop:
2471                 * fib6_add_rt2node() has reject it).
2472                 */
2473                cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
2474                rtnh = rtnh_next(rtnh, &remaining);
2475        }
2476
2477        return last_err;
2478}
2479
2480static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
2481{
2482        struct fib6_config cfg;
2483        int err;
2484
2485        err = rtm_to_fib6_config(skb, nlh, &cfg);
2486        if (err < 0)
2487                return err;
2488
2489        if (cfg.fc_mp)
2490                return ip6_route_multipath(&cfg, 0);
2491        else
2492                return ip6_route_del(&cfg);
2493}
2494
2495static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
2496{
2497        struct fib6_config cfg;
2498        int err;
2499
2500        err = rtm_to_fib6_config(skb, nlh, &cfg);
2501        if (err < 0)
2502                return err;
2503
2504        if (cfg.fc_mp)
2505                return ip6_route_multipath(&cfg, 1);
2506        else
2507                return ip6_route_add(&cfg);
2508}
2509
2510static inline size_t rt6_nlmsg_size(void)
2511{
2512        return NLMSG_ALIGN(sizeof(struct rtmsg))
2513               + nla_total_size(16) /* RTA_SRC */
2514               + nla_total_size(16) /* RTA_DST */
2515               + nla_total_size(16) /* RTA_GATEWAY */
2516               + nla_total_size(16) /* RTA_PREFSRC */
2517               + nla_total_size(4) /* RTA_TABLE */
2518               + nla_total_size(4) /* RTA_IIF */
2519               + nla_total_size(4) /* RTA_OIF */
2520               + nla_total_size(4) /* RTA_PRIORITY */
2521               + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2522               + nla_total_size(sizeof(struct rta_cacheinfo));
2523}
2524
2525static int rt6_fill_node(struct net *net,
2526                         struct sk_buff *skb, struct rt6_info *rt,
2527                         struct in6_addr *dst, struct in6_addr *src,
2528                         int iif, int type, u32 portid, u32 seq,
2529                         int prefix, int nowait, unsigned int flags)
2530{
2531        struct rtmsg *rtm;
2532        struct nlmsghdr *nlh;
2533        long expires;
2534        u32 table;
2535
2536        if (prefix) {   /* user wants prefix routes only */
2537                if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2538                        /* success since this is not a prefix route */
2539                        return 1;
2540                }
2541        }
2542
2543        nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2544        if (!nlh)
2545                return -EMSGSIZE;
2546
2547        rtm = nlmsg_data(nlh);
2548        rtm->rtm_family = AF_INET6;
2549        rtm->rtm_dst_len = rt->rt6i_dst.plen;
2550        rtm->rtm_src_len = rt->rt6i_src.plen;
2551        rtm->rtm_tos = 0;
2552        if (rt->rt6i_table)
2553                table = rt->rt6i_table->tb6_id;
2554        else
2555                table = RT6_TABLE_UNSPEC;
2556        rtm->rtm_table = table;
2557        if (nla_put_u32(skb, RTA_TABLE, table))
2558                goto nla_put_failure;
2559        if (rt->rt6i_flags & RTF_REJECT) {
2560                switch (rt->dst.error) {
2561                case -EINVAL:
2562                        rtm->rtm_type = RTN_BLACKHOLE;
2563                        break;
2564                case -EACCES:
2565                        rtm->rtm_type = RTN_PROHIBIT;
2566                        break;
2567                case -EAGAIN:
2568                        rtm->rtm_type = RTN_THROW;
2569                        break;
2570                default:
2571                        rtm->rtm_type = RTN_UNREACHABLE;
2572                        break;
2573                }
2574        }
2575        else if (rt->rt6i_flags & RTF_LOCAL)
2576                rtm->rtm_type = RTN_LOCAL;
2577        else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2578                rtm->rtm_type = RTN_LOCAL;
2579        else
2580                rtm->rtm_type = RTN_UNICAST;
2581        rtm->rtm_flags = 0;
2582        rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2583        rtm->rtm_protocol = rt->rt6i_protocol;
2584        if (rt->rt6i_flags & RTF_DYNAMIC)
2585                rtm->rtm_protocol = RTPROT_REDIRECT;
2586        else if (rt->rt6i_flags & RTF_ADDRCONF) {
2587                if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2588                        rtm->rtm_protocol = RTPROT_RA;
2589                else
2590                        rtm->rtm_protocol = RTPROT_KERNEL;
2591        }
2592
2593        if (rt->rt6i_flags & RTF_CACHE)
2594                rtm->rtm_flags |= RTM_F_CLONED;
2595
2596        if (dst) {
2597                if (nla_put(skb, RTA_DST, 16, dst))
2598                        goto nla_put_failure;
2599                rtm->rtm_dst_len = 128;
2600        } else if (rtm->rtm_dst_len)
2601                if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2602                        goto nla_put_failure;
2603#ifdef CONFIG_IPV6_SUBTREES
2604        if (src) {
2605                if (nla_put(skb, RTA_SRC, 16, src))
2606                        goto nla_put_failure;
2607                rtm->rtm_src_len = 128;
2608        } else if (rtm->rtm_src_len &&
2609                   nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2610                goto nla_put_failure;
2611#endif
2612        if (iif) {
2613#ifdef CONFIG_IPV6_MROUTE
2614                if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2615                        int err = ip6mr_get_route(net, skb, rtm, nowait,
2616                                                  portid);
2617
2618                        if (err <= 0) {
2619                                if (!nowait) {
2620                                        if (err == 0)
2621                                                return 0;
2622                                        goto nla_put_failure;
2623                                } else {
2624                                        if (err == -EMSGSIZE)
2625                                                goto nla_put_failure;
2626                                }
2627                        }
2628                } else
2629#endif
2630                        if (nla_put_u32(skb, RTA_IIF, iif))
2631                                goto nla_put_failure;
2632        } else if (dst) {
2633                struct in6_addr saddr_buf;
2634                if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2635                    nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2636                        goto nla_put_failure;
2637        }
2638
2639        if (rt->rt6i_prefsrc.plen) {
2640                struct in6_addr saddr_buf;
2641                saddr_buf = rt->rt6i_prefsrc.addr;
2642                if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2643                        goto nla_put_failure;
2644        }
2645
2646        if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2647                goto nla_put_failure;
2648
2649        if (rt->rt6i_flags & RTF_GATEWAY) {
2650                if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2651                        goto nla_put_failure;
2652        }
2653
2654        if (rt->dst.dev &&
2655            nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2656                goto nla_put_failure;
2657        if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2658                goto nla_put_failure;
2659
2660        expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2661
2662        if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2663                goto nla_put_failure;
2664
2665        return nlmsg_end(skb, nlh);
2666
2667nla_put_failure:
2668        nlmsg_cancel(skb, nlh);
2669        return -EMSGSIZE;
2670}
2671
2672int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2673{
2674        struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2675        int prefix;
2676
2677        if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2678                struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2679                prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2680        } else
2681                prefix = 0;
2682
2683        return rt6_fill_node(arg->net,
2684                     arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2685                     NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2686                     prefix, 0, NLM_F_MULTI);
2687}
2688
2689static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2690{
2691        struct net *net = sock_net(in_skb->sk);
2692        struct nlattr *tb[RTA_MAX+1];
2693        struct rt6_info *rt;
2694        struct sk_buff *skb;
2695        struct rtmsg *rtm;
2696        struct flowi6 fl6;
2697        int err, iif = 0, oif = 0;
2698
2699        err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2700        if (err < 0)
2701                goto errout;
2702
2703        err = -EINVAL;
2704        memset(&fl6, 0, sizeof(fl6));
2705
2706        if (tb[RTA_SRC]) {
2707                if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2708                        goto errout;
2709
2710                fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2711        }
2712
2713        if (tb[RTA_DST]) {
2714                if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2715                        goto errout;
2716
2717                fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2718        }
2719
2720        if (tb[RTA_IIF])
2721                iif = nla_get_u32(tb[RTA_IIF]);
2722
2723        if (tb[RTA_OIF])
2724                oif = nla_get_u32(tb[RTA_OIF]);
2725
2726        if (tb[RTA_MARK])
2727                fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2728
2729        if (iif) {
2730                struct net_device *dev;
2731                int flags = 0;
2732
2733                dev = __dev_get_by_index(net, iif);
2734                if (!dev) {
2735                        err = -ENODEV;
2736                        goto errout;
2737                }
2738
2739                fl6.flowi6_iif = iif;
2740
2741                if (!ipv6_addr_any(&fl6.saddr))
2742                        flags |= RT6_LOOKUP_F_HAS_SADDR;
2743
2744                rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2745                                                               flags);
2746        } else {
2747                fl6.flowi6_oif = oif;
2748
2749                rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2750        }
2751
2752        skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2753        if (!skb) {
2754                ip6_rt_put(rt);
2755                err = -ENOBUFS;
2756                goto errout;
2757        }
2758
2759        /* Reserve room for dummy headers, this skb can pass
2760           through good chunk of routing engine.
2761         */
2762        skb_reset_mac_header(skb);
2763        skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2764
2765        skb_dst_set(skb, &rt->dst);
2766
2767        err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2768                            RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2769                            nlh->nlmsg_seq, 0, 0, 0);
2770        if (err < 0) {
2771                kfree_skb(skb);
2772                goto errout;
2773        }
2774
2775        err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2776errout:
2777        return err;
2778}
2779
2780void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2781{
2782        struct sk_buff *skb;
2783        struct net *net = info->nl_net;
2784        u32 seq;
2785        int err;
2786
2787        err = -ENOBUFS;
2788        seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2789
2790        skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2791        if (!skb)
2792                goto errout;
2793
2794        err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2795                                event, info->portid, seq, 0, 0, 0);
2796        if (err < 0) {
2797                /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2798                WARN_ON(err == -EMSGSIZE);
2799                kfree_skb(skb);
2800                goto errout;
2801        }
2802        rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2803                    info->nlh, gfp_any());
2804        return;
2805errout:
2806        if (err < 0)
2807                rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2808}
2809
2810static int ip6_route_dev_notify(struct notifier_block *this,
2811                                unsigned long event, void *ptr)
2812{
2813        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2814        struct net *net = dev_net(dev);
2815
2816        if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2817                net->ipv6.ip6_null_entry->dst.dev = dev;
2818                net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2819#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2820                net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2821                net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2822                net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2823                net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2824#endif
2825        }
2826
2827        return NOTIFY_OK;
2828}
2829
2830/*
2831 *      /proc
2832 */
2833
2834#ifdef CONFIG_PROC_FS
2835
2836static const struct file_operations ipv6_route_proc_fops = {
2837        .owner          = THIS_MODULE,
2838        .open           = ipv6_route_open,
2839        .read           = seq_read,
2840        .llseek         = seq_lseek,
2841        .release        = seq_release_net,
2842};
2843
2844static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2845{
2846        struct net *net = (struct net *)seq->private;
2847        seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2848                   net->ipv6.rt6_stats->fib_nodes,
2849                   net->ipv6.rt6_stats->fib_route_nodes,
2850                   net->ipv6.rt6_stats->fib_rt_alloc,
2851                   net->ipv6.rt6_stats->fib_rt_entries,
2852                   net->ipv6.rt6_stats->fib_rt_cache,
2853                   dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2854                   net->ipv6.rt6_stats->fib_discarded_routes);
2855
2856        return 0;
2857}
2858
2859static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2860{
2861        return single_open_net(inode, file, rt6_stats_seq_show);
2862}
2863
2864static const struct file_operations rt6_stats_seq_fops = {
2865        .owner   = THIS_MODULE,
2866        .open    = rt6_stats_seq_open,
2867        .read    = seq_read,
2868        .llseek  = seq_lseek,
2869        .release = single_release_net,
2870};
2871#endif  /* CONFIG_PROC_FS */
2872
2873#ifdef CONFIG_SYSCTL
2874
2875static
2876int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
2877                              void __user *buffer, size_t *lenp, loff_t *ppos)
2878{
2879        struct net *net;
2880        int delay;
2881        if (!write)
2882                return -EINVAL;
2883
2884        net = (struct net *)ctl->extra1;
2885        delay = net->ipv6.sysctl.flush_delay;
2886        proc_dointvec(ctl, write, buffer, lenp, ppos);
2887        fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
2888        return 0;
2889}
2890
2891struct ctl_table ipv6_route_table_template[] = {
2892        {
2893                .procname       =       "flush",
2894                .data           =       &init_net.ipv6.sysctl.flush_delay,
2895                .maxlen         =       sizeof(int),
2896                .mode           =       0200,
2897                .proc_handler   =       ipv6_sysctl_rtcache_flush
2898        },
2899        {
2900                .procname       =       "gc_thresh",
2901                .data           =       &ip6_dst_ops_template.gc_thresh,
2902                .maxlen         =       sizeof(int),
2903                .mode           =       0644,
2904                .proc_handler   =       proc_dointvec,
2905        },
2906        {
2907                .procname       =       "max_size",
2908                .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
2909                .maxlen         =       sizeof(int),
2910                .mode           =       0644,
2911                .proc_handler   =       proc_dointvec,
2912        },
2913        {
2914                .procname       =       "gc_min_interval",
2915                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2916                .maxlen         =       sizeof(int),
2917                .mode           =       0644,
2918                .proc_handler   =       proc_dointvec_jiffies,
2919        },
2920        {
2921                .procname       =       "gc_timeout",
2922                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2923                .maxlen         =       sizeof(int),
2924                .mode           =       0644,
2925                .proc_handler   =       proc_dointvec_jiffies,
2926        },
2927        {
2928                .procname       =       "gc_interval",
2929                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2930                .maxlen         =       sizeof(int),
2931                .mode           =       0644,
2932                .proc_handler   =       proc_dointvec_jiffies,
2933        },
2934        {
2935                .procname       =       "gc_elasticity",
2936                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2937                .maxlen         =       sizeof(int),
2938                .mode           =       0644,
2939                .proc_handler   =       proc_dointvec,
2940        },
2941        {
2942                .procname       =       "mtu_expires",
2943                .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2944                .maxlen         =       sizeof(int),
2945                .mode           =       0644,
2946                .proc_handler   =       proc_dointvec_jiffies,
2947        },
2948        {
2949                .procname       =       "min_adv_mss",
2950                .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2951                .maxlen         =       sizeof(int),
2952                .mode           =       0644,
2953                .proc_handler   =       proc_dointvec,
2954        },
2955        {
2956                .procname       =       "gc_min_interval_ms",
2957                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2958                .maxlen         =       sizeof(int),
2959                .mode           =       0644,
2960                .proc_handler   =       proc_dointvec_ms_jiffies,
2961        },
2962        { }
2963};
2964
2965struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2966{
2967        struct ctl_table *table;
2968
2969        table = kmemdup(ipv6_route_table_template,
2970                        sizeof(ipv6_route_table_template),
2971                        GFP_KERNEL);
2972
2973        if (table) {
2974                table[0].data = &net->ipv6.sysctl.flush_delay;
2975                table[0].extra1 = net;
2976                table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2977                table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2978                table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2979                table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2980                table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2981                table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2982                table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2983                table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2984                table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2985
2986                /* Don't export sysctls to unprivileged users */
2987                if (net->user_ns != &init_user_ns)
2988                        table[0].procname = NULL;
2989        }
2990
2991        return table;
2992}
2993#endif
2994
2995static int __net_init ip6_route_net_init(struct net *net)
2996{
2997        int ret = -ENOMEM;
2998
2999        memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3000               sizeof(net->ipv6.ip6_dst_ops));
3001
3002        if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3003                goto out_ip6_dst_ops;
3004
3005        net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3006                                           sizeof(*net->ipv6.ip6_null_entry),
3007                                           GFP_KERNEL);
3008        if (!net->ipv6.ip6_null_entry)
3009                goto out_ip6_dst_entries;
3010        net->ipv6.ip6_null_entry->dst.path =
3011                (struct dst_entry *)net->ipv6.ip6_null_entry;
3012        net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3013        dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3014                         ip6_template_metrics, true);
3015
3016#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3017        net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3018                                               sizeof(*net->ipv6.ip6_prohibit_entry),
3019                                               GFP_KERNEL);
3020        if (!net->ipv6.ip6_prohibit_entry)
3021                goto out_ip6_null_entry;
3022        net->ipv6.ip6_prohibit_entry->dst.path =
3023                (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3024        net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3025        dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3026                         ip6_template_metrics, true);
3027
3028        net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3029                                               sizeof(*net->ipv6.ip6_blk_hole_entry),
3030                                               GFP_KERNEL);
3031        if (!net->ipv6.ip6_blk_hole_entry)
3032                goto out_ip6_prohibit_entry;
3033        net->ipv6.ip6_blk_hole_entry->dst.path =
3034                (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3035        net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3036        dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3037                         ip6_template_metrics, true);
3038#endif
3039
3040        net->ipv6.sysctl.flush_delay = 0;
3041        net->ipv6.sysctl.ip6_rt_max_size = 4096;
3042        net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3043        net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3044        net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3045        net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3046        net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3047        net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3048
3049        net->ipv6.ip6_rt_gc_expire = 30*HZ;
3050
3051        ret = 0;
3052out:
3053        return ret;
3054
3055#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3056out_ip6_prohibit_entry:
3057        kfree(net->ipv6.ip6_prohibit_entry);
3058out_ip6_null_entry:
3059        kfree(net->ipv6.ip6_null_entry);
3060#endif
3061out_ip6_dst_entries:
3062        dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3063out_ip6_dst_ops:
3064        goto out;
3065}
3066
3067static void __net_exit ip6_route_net_exit(struct net *net)
3068{
3069        kfree(net->ipv6.ip6_null_entry);
3070#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3071        kfree(net->ipv6.ip6_prohibit_entry);
3072        kfree(net->ipv6.ip6_blk_hole_entry);
3073#endif
3074        dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3075}
3076
3077static int __net_init ip6_route_net_init_late(struct net *net)
3078{
3079#ifdef CONFIG_PROC_FS
3080        proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3081        proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3082#endif
3083        return 0;
3084}
3085
3086static void __net_exit ip6_route_net_exit_late(struct net *net)
3087{
3088#ifdef CONFIG_PROC_FS
3089        remove_proc_entry("ipv6_route", net->proc_net);
3090        remove_proc_entry("rt6_stats", net->proc_net);
3091#endif
3092}
3093
3094static struct pernet_operations ip6_route_net_ops = {
3095        .init = ip6_route_net_init,
3096        .exit = ip6_route_net_exit,
3097};
3098
3099static int __net_init ipv6_inetpeer_init(struct net *net)
3100{
3101        struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3102
3103        if (!bp)
3104                return -ENOMEM;
3105        inet_peer_base_init(bp);
3106        net->ipv6.peers = bp;
3107        return 0;
3108}
3109
3110static void __net_exit ipv6_inetpeer_exit(struct net *net)
3111{
3112        struct inet_peer_base *bp = net->ipv6.peers;
3113
3114        net->ipv6.peers = NULL;
3115        inetpeer_invalidate_tree(bp);
3116        kfree(bp);
3117}
3118
3119static struct pernet_operations ipv6_inetpeer_ops = {
3120        .init   =       ipv6_inetpeer_init,
3121        .exit   =       ipv6_inetpeer_exit,
3122};
3123
3124static struct pernet_operations ip6_route_net_late_ops = {
3125        .init = ip6_route_net_init_late,
3126        .exit = ip6_route_net_exit_late,
3127};
3128
3129static struct notifier_block ip6_route_dev_notifier = {
3130        .notifier_call = ip6_route_dev_notify,
3131        .priority = 0,
3132};
3133
3134int __init ip6_route_init(void)
3135{
3136        int ret;
3137
3138        ret = -ENOMEM;
3139        ip6_dst_ops_template.kmem_cachep =
3140                kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3141                                  SLAB_HWCACHE_ALIGN, NULL);
3142        if (!ip6_dst_ops_template.kmem_cachep)
3143                goto out;
3144
3145        ret = dst_entries_init(&ip6_dst_blackhole_ops);
3146        if (ret)
3147                goto out_kmem_cache;
3148
3149        ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3150        if (ret)
3151                goto out_dst_entries;
3152
3153        ret = register_pernet_subsys(&ip6_route_net_ops);
3154        if (ret)
3155                goto out_register_inetpeer;
3156
3157        ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3158
3159        /* Registering of the loopback is done before this portion of code,
3160         * the loopback reference in rt6_info will not be taken, do it
3161         * manually for init_net */
3162        init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3163        init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3164  #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3165        init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3166        init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3167        init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3168        init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3169  #endif
3170        ret = fib6_init();
3171        if (ret)
3172                goto out_register_subsys;
3173
3174        ret = xfrm6_init();
3175        if (ret)
3176                goto out_fib6_init;
3177
3178        ret = fib6_rules_init();
3179        if (ret)
3180                goto xfrm6_init;
3181
3182        ret = register_pernet_subsys(&ip6_route_net_late_ops);
3183        if (ret)
3184                goto fib6_rules_init;
3185
3186        ret = -ENOBUFS;
3187        if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3188            __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3189            __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3190                goto out_register_late_subsys;
3191
3192        ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3193        if (ret)
3194                goto out_register_late_subsys;
3195
3196out:
3197        return ret;
3198
3199out_register_late_subsys:
3200        unregister_pernet_subsys(&ip6_route_net_late_ops);
3201fib6_rules_init:
3202        fib6_rules_cleanup();
3203xfrm6_init:
3204        xfrm6_fini();
3205out_fib6_init:
3206        fib6_gc_cleanup();
3207out_register_subsys:
3208        unregister_pernet_subsys(&ip6_route_net_ops);
3209out_register_inetpeer:
3210        unregister_pernet_subsys(&ipv6_inetpeer_ops);
3211out_dst_entries:
3212        dst_entries_destroy(&ip6_dst_blackhole_ops);
3213out_kmem_cache:
3214        kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3215        goto out;
3216}
3217
3218void ip6_route_cleanup(void)
3219{
3220        unregister_netdevice_notifier(&ip6_route_dev_notifier);
3221        unregister_pernet_subsys(&ip6_route_net_late_ops);
3222        fib6_rules_cleanup();
3223        xfrm6_fini();
3224        fib6_gc_cleanup();
3225        unregister_pernet_subsys(&ipv6_inetpeer_ops);
3226        unregister_pernet_subsys(&ip6_route_net_ops);
3227        dst_entries_destroy(&ip6_dst_blackhole_ops);
3228        kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3229}
Note: See TracBrowser for help on using the repository browser.