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

Last change on this file since 31885 was 31885, checked in by brainslayer, 3 months ago

update

File size: 77.4 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                        if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
1735                                continue;
1736                        dst_hold(&rt->dst);
1737                        read_unlock_bh(&table->tb6_lock);
1738
1739                        return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1740                }
1741        }
1742        read_unlock_bh(&table->tb6_lock);
1743
1744        return err;
1745}
1746
1747static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1748{
1749        struct net *net = dev_net(skb->dev);
1750        struct netevent_redirect netevent;
1751        struct rt6_info *rt, *nrt = NULL;
1752        struct ndisc_options ndopts;
1753        struct inet6_dev *in6_dev;
1754        struct neighbour *neigh;
1755        struct rd_msg *msg;
1756        int optlen, on_link;
1757        u8 *lladdr;
1758
1759        optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
1760        optlen -= sizeof(*msg);
1761
1762        if (optlen < 0) {
1763                net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1764                return;
1765        }
1766
1767        msg = (struct rd_msg *)icmp6_hdr(skb);
1768
1769        if (ipv6_addr_is_multicast(&msg->dest)) {
1770                net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1771                return;
1772        }
1773
1774        on_link = 0;
1775        if (ipv6_addr_equal(&msg->dest, &msg->target)) {
1776                on_link = 1;
1777        } else if (ipv6_addr_type(&msg->target) !=
1778                   (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1779                net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1780                return;
1781        }
1782
1783        in6_dev = __in6_dev_get(skb->dev);
1784        if (!in6_dev)
1785                return;
1786        if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1787                return;
1788
1789        /* RFC2461 8.1:
1790         *      The IP source address of the Redirect MUST be the same as the current
1791         *      first-hop router for the specified ICMP Destination Address.
1792         */
1793
1794        if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
1795                net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1796                return;
1797        }
1798
1799        lladdr = NULL;
1800        if (ndopts.nd_opts_tgt_lladdr) {
1801                lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1802                                             skb->dev);
1803                if (!lladdr) {
1804                        net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1805                        return;
1806                }
1807        }
1808
1809        rt = (struct rt6_info *) dst;
1810        if (rt == net->ipv6.ip6_null_entry) {
1811                net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1812                return;
1813        }
1814
1815        /* Redirect received -> path was valid.
1816         * Look, redirects are sent only in response to data packets,
1817         * so that this nexthop apparently is reachable. --ANK
1818         */
1819        dst_confirm(&rt->dst);
1820
1821        neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
1822        if (!neigh)
1823                return;
1824
1825        /*
1826         *      We have finally decided to accept it.
1827         */
1828
1829        neigh_update(neigh, lladdr, NUD_STALE,
1830                     NEIGH_UPDATE_F_WEAK_OVERRIDE|
1831                     NEIGH_UPDATE_F_OVERRIDE|
1832                     (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1833                                     NEIGH_UPDATE_F_ISROUTER))
1834                     );
1835
1836        nrt = ip6_rt_copy(rt, &msg->dest);
1837        if (!nrt)
1838                goto out;
1839
1840        nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1841        if (on_link)
1842                nrt->rt6i_flags &= ~RTF_GATEWAY;
1843
1844        nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1845
1846        if (ip6_ins_rt(nrt))
1847                goto out;
1848
1849        netevent.old = &rt->dst;
1850        netevent.new = &nrt->dst;
1851        netevent.daddr = &msg->dest;
1852        netevent.neigh = neigh;
1853        call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1854
1855        if (rt->rt6i_flags & RTF_CACHE) {
1856                rt = (struct rt6_info *) dst_clone(&rt->dst);
1857                ip6_del_rt(rt);
1858        }
1859
1860out:
1861        neigh_release(neigh);
1862}
1863
1864/*
1865 *      Misc support functions
1866 */
1867
1868static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1869                                    const struct in6_addr *dest)
1870{
1871        struct net *net = dev_net(ort->dst.dev);
1872        struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1873                                            ort->rt6i_table);
1874
1875        if (rt) {
1876                rt->dst.input = ort->dst.input;
1877                rt->dst.output = ort->dst.output;
1878                rt->dst.flags |= DST_HOST;
1879
1880                rt->rt6i_dst.addr = *dest;
1881                rt->rt6i_dst.plen = 128;
1882                dst_copy_metrics(&rt->dst, &ort->dst);
1883                rt->dst.error = ort->dst.error;
1884                rt->rt6i_idev = ort->rt6i_idev;
1885                if (rt->rt6i_idev)
1886                        in6_dev_hold(rt->rt6i_idev);
1887                rt->dst.lastuse = jiffies;
1888
1889                if (ort->rt6i_flags & RTF_GATEWAY)
1890                        rt->rt6i_gateway = ort->rt6i_gateway;
1891                else
1892                        rt->rt6i_gateway = *dest;
1893                rt->rt6i_flags = ort->rt6i_flags;
1894                rt6_set_from(rt, ort);
1895                rt->rt6i_metric = 0;
1896
1897#ifdef CONFIG_IPV6_SUBTREES
1898                memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1899#endif
1900                memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1901                rt->rt6i_table = ort->rt6i_table;
1902        }
1903        return rt;
1904}
1905
1906#ifdef CONFIG_IPV6_ROUTE_INFO
1907static struct rt6_info *rt6_get_route_info(struct net *net,
1908                                           const struct in6_addr *prefix, int prefixlen,
1909                                           const struct in6_addr *gwaddr, int ifindex)
1910{
1911        struct fib6_node *fn;
1912        struct rt6_info *rt = NULL;
1913        struct fib6_table *table;
1914
1915        table = fib6_get_table(net, RT6_TABLE_INFO);
1916        if (!table)
1917                return NULL;
1918
1919        read_lock_bh(&table->tb6_lock);
1920        fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
1921        if (!fn)
1922                goto out;
1923
1924        for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1925                if (rt->dst.dev->ifindex != ifindex)
1926                        continue;
1927                if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1928                        continue;
1929                if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1930                        continue;
1931                dst_hold(&rt->dst);
1932                break;
1933        }
1934out:
1935        read_unlock_bh(&table->tb6_lock);
1936        return rt;
1937}
1938
1939static struct rt6_info *rt6_add_route_info(struct net *net,
1940                                           const struct in6_addr *prefix, int prefixlen,
1941                                           const struct in6_addr *gwaddr, int ifindex,
1942                                           unsigned int pref)
1943{
1944        struct fib6_config cfg = {
1945                .fc_table       = RT6_TABLE_INFO,
1946                .fc_metric      = IP6_RT_PRIO_USER,
1947                .fc_ifindex     = ifindex,
1948                .fc_dst_len     = prefixlen,
1949                .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1950                                  RTF_UP | RTF_PREF(pref),
1951                .fc_nlinfo.portid = 0,
1952                .fc_nlinfo.nlh = NULL,
1953                .fc_nlinfo.nl_net = net,
1954        };
1955
1956        cfg.fc_dst = *prefix;
1957        cfg.fc_gateway = *gwaddr;
1958
1959        /* We should treat it as a default route if prefix length is 0. */
1960        if (!prefixlen)
1961                cfg.fc_flags |= RTF_DEFAULT;
1962
1963        ip6_route_add(&cfg);
1964
1965        return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1966}
1967#endif
1968
1969struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1970{
1971        struct rt6_info *rt;
1972        struct fib6_table *table;
1973
1974        table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1975        if (!table)
1976                return NULL;
1977
1978        read_lock_bh(&table->tb6_lock);
1979        for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1980                if (dev == rt->dst.dev &&
1981                    ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1982                    ipv6_addr_equal(&rt->rt6i_gateway, addr))
1983                        break;
1984        }
1985        if (rt)
1986                dst_hold(&rt->dst);
1987        read_unlock_bh(&table->tb6_lock);
1988        return rt;
1989}
1990
1991struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1992                                     struct net_device *dev,
1993                                     unsigned int pref)
1994{
1995        struct fib6_config cfg = {
1996                .fc_table       = RT6_TABLE_DFLT,
1997                .fc_metric      = IP6_RT_PRIO_USER,
1998                .fc_ifindex     = dev->ifindex,
1999                .fc_flags       = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2000                                  RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2001                .fc_nlinfo.portid = 0,
2002                .fc_nlinfo.nlh = NULL,
2003                .fc_nlinfo.nl_net = dev_net(dev),
2004        };
2005
2006        cfg.fc_gateway = *gwaddr;
2007
2008        ip6_route_add(&cfg);
2009
2010        return rt6_get_dflt_router(gwaddr, dev);
2011}
2012
2013void rt6_purge_dflt_routers(struct net *net)
2014{
2015        struct rt6_info *rt;
2016        struct fib6_table *table;
2017
2018        /* NOTE: Keep consistent with rt6_get_dflt_router */
2019        table = fib6_get_table(net, RT6_TABLE_DFLT);
2020        if (!table)
2021                return;
2022
2023restart:
2024        read_lock_bh(&table->tb6_lock);
2025        for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2026                if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2027                    (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2028                        dst_hold(&rt->dst);
2029                        read_unlock_bh(&table->tb6_lock);
2030                        ip6_del_rt(rt);
2031                        goto restart;
2032                }
2033        }
2034        read_unlock_bh(&table->tb6_lock);
2035}
2036
2037static void rtmsg_to_fib6_config(struct net *net,
2038                                 struct in6_rtmsg *rtmsg,
2039                                 struct fib6_config *cfg)
2040{
2041        memset(cfg, 0, sizeof(*cfg));
2042
2043        cfg->fc_table = RT6_TABLE_MAIN;
2044        cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2045        cfg->fc_metric = rtmsg->rtmsg_metric;
2046        cfg->fc_expires = rtmsg->rtmsg_info;
2047        cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2048        cfg->fc_src_len = rtmsg->rtmsg_src_len;
2049        cfg->fc_flags = rtmsg->rtmsg_flags;
2050
2051        cfg->fc_nlinfo.nl_net = net;
2052
2053        cfg->fc_dst = rtmsg->rtmsg_dst;
2054        cfg->fc_src = rtmsg->rtmsg_src;
2055        cfg->fc_gateway = rtmsg->rtmsg_gateway;
2056}
2057
2058int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2059{
2060        struct fib6_config cfg;
2061        struct in6_rtmsg rtmsg;
2062        int err;
2063
2064        switch (cmd) {
2065        case SIOCADDRT:         /* Add a route */
2066        case SIOCDELRT:         /* Delete a route */
2067                if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2068                        return -EPERM;
2069                err = copy_from_user(&rtmsg, arg,
2070                                     sizeof(struct in6_rtmsg));
2071                if (err)
2072                        return -EFAULT;
2073
2074                rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2075
2076                rtnl_lock();
2077                switch (cmd) {
2078                case SIOCADDRT:
2079                        err = ip6_route_add(&cfg);
2080                        break;
2081                case SIOCDELRT:
2082                        err = ip6_route_del(&cfg);
2083                        break;
2084                default:
2085                        err = -EINVAL;
2086                }
2087                rtnl_unlock();
2088
2089                return err;
2090        }
2091
2092        return -EINVAL;
2093}
2094
2095/*
2096 *      Drop the packet on the floor
2097 */
2098
2099static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2100{
2101        int type;
2102        struct dst_entry *dst = skb_dst(skb);
2103        switch (ipstats_mib_noroutes) {
2104        case IPSTATS_MIB_INNOROUTES:
2105                type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2106                if (type == IPV6_ADDR_ANY) {
2107                        IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2108                                      IPSTATS_MIB_INADDRERRORS);
2109                        break;
2110                }
2111                /* FALLTHROUGH */
2112        case IPSTATS_MIB_OUTNOROUTES:
2113                IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2114                              ipstats_mib_noroutes);
2115                break;
2116        }
2117        icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2118        kfree_skb(skb);
2119        return 0;
2120}
2121
2122static int ip6_pkt_discard(struct sk_buff *skb)
2123{
2124        return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2125}
2126
2127static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)
2128{
2129        skb->dev = skb_dst(skb)->dev;
2130        return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2131}
2132
2133static int ip6_pkt_prohibit(struct sk_buff *skb)
2134{
2135        return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2136}
2137
2138static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)
2139{
2140        skb->dev = skb_dst(skb)->dev;
2141        return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2142}
2143
2144/*
2145 *      Allocate a dst for local (unicast / anycast) address.
2146 */
2147
2148struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2149                                    const struct in6_addr *addr,
2150                                    bool anycast)
2151{
2152        struct net *net = dev_net(idev->dev);
2153        struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2154                                            DST_NOCOUNT, NULL);
2155        if (!rt)
2156                return ERR_PTR(-ENOMEM);
2157
2158        in6_dev_hold(idev);
2159
2160        rt->dst.flags |= DST_HOST;
2161        rt->dst.input = ip6_input;
2162        rt->dst.output = ip6_output;
2163        rt->rt6i_idev = idev;
2164
2165        rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2166        if (anycast)
2167                rt->rt6i_flags |= RTF_ANYCAST;
2168        else
2169                rt->rt6i_flags |= RTF_LOCAL;
2170
2171        rt->rt6i_gateway  = *addr;
2172        rt->rt6i_dst.addr = *addr;
2173        rt->rt6i_dst.plen = 128;
2174        rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2175
2176        atomic_set(&rt->dst.__refcnt, 1);
2177
2178        return rt;
2179}
2180
2181int ip6_route_get_saddr(struct net *net,
2182                        struct rt6_info *rt,
2183                        const struct in6_addr *daddr,
2184                        unsigned int prefs,
2185                        struct in6_addr *saddr)
2186{
2187        struct inet6_dev *idev = ip6_dst_idev((struct dst_entry *)rt);
2188        int err = 0;
2189        if (rt->rt6i_prefsrc.plen)
2190                *saddr = rt->rt6i_prefsrc.addr;
2191        else
2192                err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2193                                         daddr, prefs, saddr);
2194        return err;
2195}
2196
2197/* remove deleted ip from prefsrc entries */
2198struct arg_dev_net_ip {
2199        struct net_device *dev;
2200        struct net *net;
2201        struct in6_addr *addr;
2202};
2203
2204static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2205{
2206        struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2207        struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2208        struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2209
2210        if (((void *)rt->dst.dev == dev || !dev) &&
2211            rt != net->ipv6.ip6_null_entry &&
2212            ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2213                /* remove prefsrc entry */
2214                rt->rt6i_prefsrc.plen = 0;
2215        }
2216        return 0;
2217}
2218
2219void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2220{
2221        struct net *net = dev_net(ifp->idev->dev);
2222        struct arg_dev_net_ip adni = {
2223                .dev = ifp->idev->dev,
2224                .net = net,
2225                .addr = &ifp->addr,
2226        };
2227        fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2228}
2229
2230#define RTF_RA_ROUTER           (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2231#define RTF_CACHE_GATEWAY       (RTF_GATEWAY | RTF_CACHE)
2232
2233/* Remove routers and update dst entries when gateway turn into host. */
2234static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2235{
2236        struct in6_addr *gateway = (struct in6_addr *)arg;
2237
2238        if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2239             ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2240             ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2241                return -1;
2242        }
2243        return 0;
2244}
2245
2246void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2247{
2248        fib6_clean_all(net, fib6_clean_tohost, gateway);
2249}
2250
2251struct arg_dev_net {
2252        struct net_device *dev;
2253        struct net *net;
2254};
2255
2256static int fib6_ifdown(struct rt6_info *rt, void *arg)
2257{
2258        const struct arg_dev_net *adn = arg;
2259        const struct net_device *dev = adn->dev;
2260
2261        if ((rt->dst.dev == dev || !dev) &&
2262            rt != adn->net->ipv6.ip6_null_entry)
2263                return -1;
2264
2265        return 0;
2266}
2267
2268void rt6_ifdown(struct net *net, struct net_device *dev)
2269{
2270        struct arg_dev_net adn = {
2271                .dev = dev,
2272                .net = net,
2273        };
2274
2275        fib6_clean_all(net, fib6_ifdown, &adn);
2276        icmp6_clean_all(fib6_ifdown, &adn);
2277}
2278
2279struct rt6_mtu_change_arg {
2280        struct net_device *dev;
2281        unsigned int mtu;
2282};
2283
2284static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2285{
2286        struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2287        struct inet6_dev *idev;
2288
2289        /* In IPv6 pmtu discovery is not optional,
2290           so that RTAX_MTU lock cannot disable it.
2291           We still use this lock to block changes
2292           caused by addrconf/ndisc.
2293        */
2294
2295        idev = __in6_dev_get(arg->dev);
2296        if (!idev)
2297                return 0;
2298
2299        /* For administrative MTU increase, there is no way to discover
2300           IPv6 PMTU increase, so PMTU increase should be updated here.
2301           Since RFC 1981 doesn't include administrative MTU increase
2302           update PMTU increase is a MUST. (i.e. jumbo frame)
2303         */
2304        /*
2305           If new MTU is less than route PMTU, this new MTU will be the
2306           lowest MTU in the path, update the route PMTU to reflect PMTU
2307           decreases; if new MTU is greater than route PMTU, and the
2308           old MTU is the lowest MTU in the path, update the route PMTU
2309           to reflect the increase. In this case if the other nodes' MTU
2310           also have the lowest MTU, TOO BIG MESSAGE will be lead to
2311           PMTU discouvery.
2312         */
2313        if (rt->dst.dev == arg->dev &&
2314            !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2315            (dst_mtu(&rt->dst) >= arg->mtu ||
2316             (dst_mtu(&rt->dst) < arg->mtu &&
2317              dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2318                dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2319        }
2320        return 0;
2321}
2322
2323void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2324{
2325        struct rt6_mtu_change_arg arg = {
2326                .dev = dev,
2327                .mtu = mtu,
2328        };
2329
2330        fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2331}
2332
2333static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2334        [RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
2335        [RTA_OIF]               = { .type = NLA_U32 },
2336        [RTA_IIF]               = { .type = NLA_U32 },
2337        [RTA_PRIORITY]          = { .type = NLA_U32 },
2338        [RTA_METRICS]           = { .type = NLA_NESTED },
2339        [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
2340};
2341
2342static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2343                              struct fib6_config *cfg)
2344{
2345        struct rtmsg *rtm;
2346        struct nlattr *tb[RTA_MAX+1];
2347        int err;
2348
2349        err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2350        if (err < 0)
2351                goto errout;
2352
2353        err = -EINVAL;
2354        rtm = nlmsg_data(nlh);
2355        memset(cfg, 0, sizeof(*cfg));
2356
2357        cfg->fc_table = rtm->rtm_table;
2358        cfg->fc_dst_len = rtm->rtm_dst_len;
2359        cfg->fc_src_len = rtm->rtm_src_len;
2360        cfg->fc_flags = RTF_UP;
2361        cfg->fc_protocol = rtm->rtm_protocol;
2362        cfg->fc_type = rtm->rtm_type;
2363
2364        if (rtm->rtm_type == RTN_UNREACHABLE ||
2365            rtm->rtm_type == RTN_BLACKHOLE ||
2366            rtm->rtm_type == RTN_PROHIBIT ||
2367            rtm->rtm_type == RTN_THROW)
2368                cfg->fc_flags |= RTF_REJECT;
2369
2370        if (rtm->rtm_type == RTN_LOCAL)
2371                cfg->fc_flags |= RTF_LOCAL;
2372
2373        cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2374        cfg->fc_nlinfo.nlh = nlh;
2375        cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2376
2377        if (tb[RTA_GATEWAY]) {
2378                nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2379                cfg->fc_flags |= RTF_GATEWAY;
2380        }
2381
2382        if (tb[RTA_DST]) {
2383                int plen = (rtm->rtm_dst_len + 7) >> 3;
2384
2385                if (nla_len(tb[RTA_DST]) < plen)
2386                        goto errout;
2387
2388                nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2389        }
2390
2391        if (tb[RTA_SRC]) {
2392                int plen = (rtm->rtm_src_len + 7) >> 3;
2393
2394                if (nla_len(tb[RTA_SRC]) < plen)
2395                        goto errout;
2396
2397                nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2398        }
2399
2400        if (tb[RTA_PREFSRC])
2401                nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2402
2403        if (tb[RTA_OIF])
2404                cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2405
2406        if (tb[RTA_PRIORITY])
2407                cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2408
2409        if (tb[RTA_METRICS]) {
2410                cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2411                cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2412        }
2413
2414        if (tb[RTA_TABLE])
2415                cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2416
2417        if (tb[RTA_MULTIPATH]) {
2418                cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2419                cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2420        }
2421
2422        err = 0;
2423errout:
2424        return err;
2425}
2426
2427static int ip6_route_multipath(struct fib6_config *cfg, int add)
2428{
2429        struct fib6_config r_cfg;
2430        struct rtnexthop *rtnh;
2431        int remaining;
2432        int attrlen;
2433        int err = 0, last_err = 0;
2434
2435beginning:
2436        rtnh = (struct rtnexthop *)cfg->fc_mp;
2437        remaining = cfg->fc_mp_len;
2438
2439        /* Parse a Multipath Entry */
2440        while (rtnh_ok(rtnh, remaining)) {
2441                memcpy(&r_cfg, cfg, sizeof(*cfg));
2442                if (rtnh->rtnh_ifindex)
2443                        r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2444
2445                attrlen = rtnh_attrlen(rtnh);
2446                if (attrlen > 0) {
2447                        struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2448
2449                        nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2450                        if (nla) {
2451                                nla_memcpy(&r_cfg.fc_gateway, nla, 16);
2452                                r_cfg.fc_flags |= RTF_GATEWAY;
2453                        }
2454                }
2455                err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);
2456                if (err) {
2457                        last_err = err;
2458                        /* If we are trying to remove a route, do not stop the
2459                         * loop when ip6_route_del() fails (because next hop is
2460                         * already gone), we should try to remove all next hops.
2461                         */
2462                        if (add) {
2463                                /* If add fails, we should try to delete all
2464                                 * next hops that have been already added.
2465                                 */
2466                                add = 0;
2467                                goto beginning;
2468                        }
2469                }
2470                /* Because each route is added like a single route we remove
2471                 * this flag after the first nexthop (if there is a collision,
2472                 * we have already fail to add the first nexthop:
2473                 * fib6_add_rt2node() has reject it).
2474                 */
2475                cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;
2476                rtnh = rtnh_next(rtnh, &remaining);
2477        }
2478
2479        return last_err;
2480}
2481
2482static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
2483{
2484        struct fib6_config cfg;
2485        int err;
2486
2487        err = rtm_to_fib6_config(skb, nlh, &cfg);
2488        if (err < 0)
2489                return err;
2490
2491        if (cfg.fc_mp)
2492                return ip6_route_multipath(&cfg, 0);
2493        else
2494                return ip6_route_del(&cfg);
2495}
2496
2497static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
2498{
2499        struct fib6_config cfg;
2500        int err;
2501
2502        err = rtm_to_fib6_config(skb, nlh, &cfg);
2503        if (err < 0)
2504                return err;
2505
2506        if (cfg.fc_mp)
2507                return ip6_route_multipath(&cfg, 1);
2508        else
2509                return ip6_route_add(&cfg);
2510}
2511
2512static inline size_t rt6_nlmsg_size(void)
2513{
2514        return NLMSG_ALIGN(sizeof(struct rtmsg))
2515               + nla_total_size(16) /* RTA_SRC */
2516               + nla_total_size(16) /* RTA_DST */
2517               + nla_total_size(16) /* RTA_GATEWAY */
2518               + nla_total_size(16) /* RTA_PREFSRC */
2519               + nla_total_size(4) /* RTA_TABLE */
2520               + nla_total_size(4) /* RTA_IIF */
2521               + nla_total_size(4) /* RTA_OIF */
2522               + nla_total_size(4) /* RTA_PRIORITY */
2523               + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2524               + nla_total_size(sizeof(struct rta_cacheinfo));
2525}
2526
2527static int rt6_fill_node(struct net *net,
2528                         struct sk_buff *skb, struct rt6_info *rt,
2529                         struct in6_addr *dst, struct in6_addr *src,
2530                         int iif, int type, u32 portid, u32 seq,
2531                         int prefix, int nowait, unsigned int flags)
2532{
2533        struct rtmsg *rtm;
2534        struct nlmsghdr *nlh;
2535        long expires;
2536        u32 table;
2537
2538        if (prefix) {   /* user wants prefix routes only */
2539                if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2540                        /* success since this is not a prefix route */
2541                        return 1;
2542                }
2543        }
2544
2545        nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2546        if (!nlh)
2547                return -EMSGSIZE;
2548
2549        rtm = nlmsg_data(nlh);
2550        rtm->rtm_family = AF_INET6;
2551        rtm->rtm_dst_len = rt->rt6i_dst.plen;
2552        rtm->rtm_src_len = rt->rt6i_src.plen;
2553        rtm->rtm_tos = 0;
2554        if (rt->rt6i_table)
2555                table = rt->rt6i_table->tb6_id;
2556        else
2557                table = RT6_TABLE_UNSPEC;
2558        rtm->rtm_table = table;
2559        if (nla_put_u32(skb, RTA_TABLE, table))
2560                goto nla_put_failure;
2561        if (rt->rt6i_flags & RTF_REJECT) {
2562                switch (rt->dst.error) {
2563                case -EINVAL:
2564                        rtm->rtm_type = RTN_BLACKHOLE;
2565                        break;
2566                case -EACCES:
2567                        rtm->rtm_type = RTN_PROHIBIT;
2568                        break;
2569                case -EAGAIN:
2570                        rtm->rtm_type = RTN_THROW;
2571                        break;
2572                default:
2573                        rtm->rtm_type = RTN_UNREACHABLE;
2574                        break;
2575                }
2576        }
2577        else if (rt->rt6i_flags & RTF_LOCAL)
2578                rtm->rtm_type = RTN_LOCAL;
2579        else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2580                rtm->rtm_type = RTN_LOCAL;
2581        else
2582                rtm->rtm_type = RTN_UNICAST;
2583        rtm->rtm_flags = 0;
2584        rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2585        rtm->rtm_protocol = rt->rt6i_protocol;
2586        if (rt->rt6i_flags & RTF_DYNAMIC)
2587                rtm->rtm_protocol = RTPROT_REDIRECT;
2588        else if (rt->rt6i_flags & RTF_ADDRCONF) {
2589                if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2590                        rtm->rtm_protocol = RTPROT_RA;
2591                else
2592                        rtm->rtm_protocol = RTPROT_KERNEL;
2593        }
2594
2595        if (rt->rt6i_flags & RTF_CACHE)
2596                rtm->rtm_flags |= RTM_F_CLONED;
2597
2598        if (dst) {
2599                if (nla_put(skb, RTA_DST, 16, dst))
2600                        goto nla_put_failure;
2601                rtm->rtm_dst_len = 128;
2602        } else if (rtm->rtm_dst_len)
2603                if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2604                        goto nla_put_failure;
2605#ifdef CONFIG_IPV6_SUBTREES
2606        if (src) {
2607                if (nla_put(skb, RTA_SRC, 16, src))
2608                        goto nla_put_failure;
2609                rtm->rtm_src_len = 128;
2610        } else if (rtm->rtm_src_len &&
2611                   nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2612                goto nla_put_failure;
2613#endif
2614        if (iif) {
2615#ifdef CONFIG_IPV6_MROUTE
2616                if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2617                        int err = ip6mr_get_route(net, skb, rtm, nowait,
2618                                                  portid);
2619
2620                        if (err <= 0) {
2621                                if (!nowait) {
2622                                        if (err == 0)
2623                                                return 0;
2624                                        goto nla_put_failure;
2625                                } else {
2626                                        if (err == -EMSGSIZE)
2627                                                goto nla_put_failure;
2628                                }
2629                        }
2630                } else
2631#endif
2632                        if (nla_put_u32(skb, RTA_IIF, iif))
2633                                goto nla_put_failure;
2634        } else if (dst) {
2635                struct in6_addr saddr_buf;
2636                if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2637                    nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2638                        goto nla_put_failure;
2639        }
2640
2641        if (rt->rt6i_prefsrc.plen) {
2642                struct in6_addr saddr_buf;
2643                saddr_buf = rt->rt6i_prefsrc.addr;
2644                if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2645                        goto nla_put_failure;
2646        }
2647
2648        if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2649                goto nla_put_failure;
2650
2651        if (rt->rt6i_flags & RTF_GATEWAY) {
2652                if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)
2653                        goto nla_put_failure;
2654        }
2655
2656        if (rt->dst.dev &&
2657            nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2658                goto nla_put_failure;
2659        if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2660                goto nla_put_failure;
2661
2662        expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2663
2664        if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2665                goto nla_put_failure;
2666
2667        return nlmsg_end(skb, nlh);
2668
2669nla_put_failure:
2670        nlmsg_cancel(skb, nlh);
2671        return -EMSGSIZE;
2672}
2673
2674int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2675{
2676        struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2677        int prefix;
2678
2679        if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2680                struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2681                prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2682        } else
2683                prefix = 0;
2684
2685        return rt6_fill_node(arg->net,
2686                     arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2687                     NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2688                     prefix, 0, NLM_F_MULTI);
2689}
2690
2691static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2692{
2693        struct net *net = sock_net(in_skb->sk);
2694        struct nlattr *tb[RTA_MAX+1];
2695        struct rt6_info *rt;
2696        struct sk_buff *skb;
2697        struct rtmsg *rtm;
2698        struct flowi6 fl6;
2699        int err, iif = 0, oif = 0;
2700
2701        err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2702        if (err < 0)
2703                goto errout;
2704
2705        err = -EINVAL;
2706        memset(&fl6, 0, sizeof(fl6));
2707
2708        if (tb[RTA_SRC]) {
2709                if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2710                        goto errout;
2711
2712                fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2713        }
2714
2715        if (tb[RTA_DST]) {
2716                if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2717                        goto errout;
2718
2719                fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2720        }
2721
2722        if (tb[RTA_IIF])
2723                iif = nla_get_u32(tb[RTA_IIF]);
2724
2725        if (tb[RTA_OIF])
2726                oif = nla_get_u32(tb[RTA_OIF]);
2727
2728        if (tb[RTA_MARK])
2729                fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
2730
2731        if (iif) {
2732                struct net_device *dev;
2733                int flags = 0;
2734
2735                dev = __dev_get_by_index(net, iif);
2736                if (!dev) {
2737                        err = -ENODEV;
2738                        goto errout;
2739                }
2740
2741                fl6.flowi6_iif = iif;
2742
2743                if (!ipv6_addr_any(&fl6.saddr))
2744                        flags |= RT6_LOOKUP_F_HAS_SADDR;
2745
2746                rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2747                                                               flags);
2748        } else {
2749                fl6.flowi6_oif = oif;
2750
2751                rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2752        }
2753
2754        skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2755        if (!skb) {
2756                ip6_rt_put(rt);
2757                err = -ENOBUFS;
2758                goto errout;
2759        }
2760
2761        /* Reserve room for dummy headers, this skb can pass
2762           through good chunk of routing engine.
2763         */
2764        skb_reset_mac_header(skb);
2765        skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2766
2767        skb_dst_set(skb, &rt->dst);
2768
2769        err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2770                            RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2771                            nlh->nlmsg_seq, 0, 0, 0);
2772        if (err < 0) {
2773                kfree_skb(skb);
2774                goto errout;
2775        }
2776
2777        err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2778errout:
2779        return err;
2780}
2781
2782void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2783{
2784        struct sk_buff *skb;
2785        struct net *net = info->nl_net;
2786        u32 seq;
2787        int err;
2788
2789        err = -ENOBUFS;
2790        seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2791
2792        skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2793        if (!skb)
2794                goto errout;
2795
2796        err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2797                                event, info->portid, seq, 0, 0, 0);
2798        if (err < 0) {
2799                /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2800                WARN_ON(err == -EMSGSIZE);
2801                kfree_skb(skb);
2802                goto errout;
2803        }
2804        rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2805                    info->nlh, gfp_any());
2806        return;
2807errout:
2808        if (err < 0)
2809                rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2810}
2811
2812static int ip6_route_dev_notify(struct notifier_block *this,
2813                                unsigned long event, void *ptr)
2814{
2815        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2816        struct net *net = dev_net(dev);
2817
2818        if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2819                net->ipv6.ip6_null_entry->dst.dev = dev;
2820                net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2821#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2822                net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2823                net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2824                net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2825                net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2826#endif
2827        }
2828
2829        return NOTIFY_OK;
2830}
2831
2832/*
2833 *      /proc
2834 */
2835
2836#ifdef CONFIG_PROC_FS
2837
2838static const struct file_operations ipv6_route_proc_fops = {
2839        .owner          = THIS_MODULE,
2840        .open           = ipv6_route_open,
2841        .read           = seq_read,
2842        .llseek         = seq_lseek,
2843        .release        = seq_release_net,
2844};
2845
2846static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2847{
2848        struct net *net = (struct net *)seq->private;
2849        seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2850                   net->ipv6.rt6_stats->fib_nodes,
2851                   net->ipv6.rt6_stats->fib_route_nodes,
2852                   net->ipv6.rt6_stats->fib_rt_alloc,
2853                   net->ipv6.rt6_stats->fib_rt_entries,
2854                   net->ipv6.rt6_stats->fib_rt_cache,
2855                   dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2856                   net->ipv6.rt6_stats->fib_discarded_routes);
2857
2858        return 0;
2859}
2860
2861static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2862{
2863        return single_open_net(inode, file, rt6_stats_seq_show);
2864}
2865
2866static const struct file_operations rt6_stats_seq_fops = {
2867        .owner   = THIS_MODULE,
2868        .open    = rt6_stats_seq_open,
2869        .read    = seq_read,
2870        .llseek  = seq_lseek,
2871        .release = single_release_net,
2872};
2873#endif  /* CONFIG_PROC_FS */
2874
2875#ifdef CONFIG_SYSCTL
2876
2877static
2878int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
2879                              void __user *buffer, size_t *lenp, loff_t *ppos)
2880{
2881        struct net *net;
2882        int delay;
2883        if (!write)
2884                return -EINVAL;
2885
2886        net = (struct net *)ctl->extra1;
2887        delay = net->ipv6.sysctl.flush_delay;
2888        proc_dointvec(ctl, write, buffer, lenp, ppos);
2889        fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
2890        return 0;
2891}
2892
2893struct ctl_table ipv6_route_table_template[] = {
2894        {
2895                .procname       =       "flush",
2896                .data           =       &init_net.ipv6.sysctl.flush_delay,
2897                .maxlen         =       sizeof(int),
2898                .mode           =       0200,
2899                .proc_handler   =       ipv6_sysctl_rtcache_flush
2900        },
2901        {
2902                .procname       =       "gc_thresh",
2903                .data           =       &ip6_dst_ops_template.gc_thresh,
2904                .maxlen         =       sizeof(int),
2905                .mode           =       0644,
2906                .proc_handler   =       proc_dointvec,
2907        },
2908        {
2909                .procname       =       "max_size",
2910                .data           =       &init_net.ipv6.sysctl.ip6_rt_max_size,
2911                .maxlen         =       sizeof(int),
2912                .mode           =       0644,
2913                .proc_handler   =       proc_dointvec,
2914        },
2915        {
2916                .procname       =       "gc_min_interval",
2917                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2918                .maxlen         =       sizeof(int),
2919                .mode           =       0644,
2920                .proc_handler   =       proc_dointvec_jiffies,
2921        },
2922        {
2923                .procname       =       "gc_timeout",
2924                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2925                .maxlen         =       sizeof(int),
2926                .mode           =       0644,
2927                .proc_handler   =       proc_dointvec_jiffies,
2928        },
2929        {
2930                .procname       =       "gc_interval",
2931                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2932                .maxlen         =       sizeof(int),
2933                .mode           =       0644,
2934                .proc_handler   =       proc_dointvec_jiffies,
2935        },
2936        {
2937                .procname       =       "gc_elasticity",
2938                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2939                .maxlen         =       sizeof(int),
2940                .mode           =       0644,
2941                .proc_handler   =       proc_dointvec,
2942        },
2943        {
2944                .procname       =       "mtu_expires",
2945                .data           =       &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2946                .maxlen         =       sizeof(int),
2947                .mode           =       0644,
2948                .proc_handler   =       proc_dointvec_jiffies,
2949        },
2950        {
2951                .procname       =       "min_adv_mss",
2952                .data           =       &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2953                .maxlen         =       sizeof(int),
2954                .mode           =       0644,
2955                .proc_handler   =       proc_dointvec,
2956        },
2957        {
2958                .procname       =       "gc_min_interval_ms",
2959                .data           =       &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2960                .maxlen         =       sizeof(int),
2961                .mode           =       0644,
2962                .proc_handler   =       proc_dointvec_ms_jiffies,
2963        },
2964        { }
2965};
2966
2967struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2968{
2969        struct ctl_table *table;
2970
2971        table = kmemdup(ipv6_route_table_template,
2972                        sizeof(ipv6_route_table_template),
2973                        GFP_KERNEL);
2974
2975        if (table) {
2976                table[0].data = &net->ipv6.sysctl.flush_delay;
2977                table[0].extra1 = net;
2978                table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2979                table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2980                table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2981                table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2982                table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2983                table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2984                table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2985                table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2986                table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2987
2988                /* Don't export sysctls to unprivileged users */
2989                if (net->user_ns != &init_user_ns)
2990                        table[0].procname = NULL;
2991        }
2992
2993        return table;
2994}
2995#endif
2996
2997static int __net_init ip6_route_net_init(struct net *net)
2998{
2999        int ret = -ENOMEM;
3000
3001        memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3002               sizeof(net->ipv6.ip6_dst_ops));
3003
3004        if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3005                goto out_ip6_dst_ops;
3006
3007        net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3008                                           sizeof(*net->ipv6.ip6_null_entry),
3009                                           GFP_KERNEL);
3010        if (!net->ipv6.ip6_null_entry)
3011                goto out_ip6_dst_entries;
3012        net->ipv6.ip6_null_entry->dst.path =
3013                (struct dst_entry *)net->ipv6.ip6_null_entry;
3014        net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3015        dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3016                         ip6_template_metrics, true);
3017
3018#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3019        net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3020                                               sizeof(*net->ipv6.ip6_prohibit_entry),
3021                                               GFP_KERNEL);
3022        if (!net->ipv6.ip6_prohibit_entry)
3023                goto out_ip6_null_entry;
3024        net->ipv6.ip6_prohibit_entry->dst.path =
3025                (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3026        net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3027        dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3028                         ip6_template_metrics, true);
3029
3030        net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3031                                               sizeof(*net->ipv6.ip6_blk_hole_entry),
3032                                               GFP_KERNEL);
3033        if (!net->ipv6.ip6_blk_hole_entry)
3034                goto out_ip6_prohibit_entry;
3035        net->ipv6.ip6_blk_hole_entry->dst.path =
3036                (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3037        net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3038        dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3039                         ip6_template_metrics, true);
3040#endif
3041
3042        net->ipv6.sysctl.flush_delay = 0;
3043        net->ipv6.sysctl.ip6_rt_max_size = 4096;
3044        net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3045        net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3046        net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3047        net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3048        net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3049        net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3050
3051        net->ipv6.ip6_rt_gc_expire = 30*HZ;
3052
3053        ret = 0;
3054out:
3055        return ret;
3056
3057#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3058out_ip6_prohibit_entry:
3059        kfree(net->ipv6.ip6_prohibit_entry);
3060out_ip6_null_entry:
3061        kfree(net->ipv6.ip6_null_entry);
3062#endif
3063out_ip6_dst_entries:
3064        dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3065out_ip6_dst_ops:
3066        goto out;
3067}
3068
3069static void __net_exit ip6_route_net_exit(struct net *net)
3070{
3071        kfree(net->ipv6.ip6_null_entry);
3072#ifdef CONFIG_IPV6_MULTIPLE_TABLES
3073        kfree(net->ipv6.ip6_prohibit_entry);
3074        kfree(net->ipv6.ip6_blk_hole_entry);
3075#endif
3076        dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3077}
3078
3079static int __net_init ip6_route_net_init_late(struct net *net)
3080{
3081#ifdef CONFIG_PROC_FS
3082        proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3083        proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3084#endif
3085        return 0;
3086}
3087
3088static void __net_exit ip6_route_net_exit_late(struct net *net)
3089{
3090#ifdef CONFIG_PROC_FS
3091        remove_proc_entry("ipv6_route", net->proc_net);
3092        remove_proc_entry("rt6_stats", net->proc_net);
3093#endif
3094}
3095
3096static struct pernet_operations ip6_route_net_ops = {
3097        .init = ip6_route_net_init,
3098        .exit = ip6_route_net_exit,
3099};
3100
3101static int __net_init ipv6_inetpeer_init(struct net *net)
3102{
3103        struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3104
3105        if (!bp)
3106                return -ENOMEM;
3107        inet_peer_base_init(bp);
3108        net->ipv6.peers = bp;
3109        return 0;
3110}
3111
3112static void __net_exit ipv6_inetpeer_exit(struct net *net)
3113{
3114        struct inet_peer_base *bp = net->ipv6.peers;
3115
3116        net->ipv6.peers = NULL;
3117        inetpeer_invalidate_tree(bp);
3118        kfree(bp);
3119}
3120
3121static struct pernet_operations ipv6_inetpeer_ops = {
3122        .init   =       ipv6_inetpeer_init,
3123        .exit   =       ipv6_inetpeer_exit,
3124};
3125
3126static struct pernet_operations ip6_route_net_late_ops = {
3127        .init = ip6_route_net_init_late,
3128        .exit = ip6_route_net_exit_late,
3129};
3130
3131static struct notifier_block ip6_route_dev_notifier = {
3132        .notifier_call = ip6_route_dev_notify,
3133        .priority = 0,
3134};
3135
3136int __init ip6_route_init(void)
3137{
3138        int ret;
3139
3140        ret = -ENOMEM;
3141        ip6_dst_ops_template.kmem_cachep =
3142                kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3143                                  SLAB_HWCACHE_ALIGN, NULL);
3144        if (!ip6_dst_ops_template.kmem_cachep)
3145                goto out;
3146
3147        ret = dst_entries_init(&ip6_dst_blackhole_ops);
3148        if (ret)
3149                goto out_kmem_cache;
3150
3151        ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3152        if (ret)
3153                goto out_dst_entries;
3154
3155        ret = register_pernet_subsys(&ip6_route_net_ops);
3156        if (ret)
3157                goto out_register_inetpeer;
3158
3159        ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3160
3161        /* Registering of the loopback is done before this portion of code,
3162         * the loopback reference in rt6_info will not be taken, do it
3163         * manually for init_net */
3164        init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3165        init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3166  #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3167        init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3168        init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3169        init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3170        init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3171  #endif
3172        ret = fib6_init();
3173        if (ret)
3174                goto out_register_subsys;
3175
3176        ret = xfrm6_init();
3177        if (ret)
3178                goto out_fib6_init;
3179
3180        ret = fib6_rules_init();
3181        if (ret)
3182                goto xfrm6_init;
3183
3184        ret = register_pernet_subsys(&ip6_route_net_late_ops);
3185        if (ret)
3186                goto fib6_rules_init;
3187
3188        ret = -ENOBUFS;
3189        if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3190            __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3191            __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3192                goto out_register_late_subsys;
3193
3194        ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3195        if (ret)
3196                goto out_register_late_subsys;
3197
3198out:
3199        return ret;
3200
3201out_register_late_subsys:
3202        unregister_pernet_subsys(&ip6_route_net_late_ops);
3203fib6_rules_init:
3204        fib6_rules_cleanup();
3205xfrm6_init:
3206        xfrm6_fini();
3207out_fib6_init:
3208        fib6_gc_cleanup();
3209out_register_subsys:
3210        unregister_pernet_subsys(&ip6_route_net_ops);
3211out_register_inetpeer:
3212        unregister_pernet_subsys(&ipv6_inetpeer_ops);
3213out_dst_entries:
3214        dst_entries_destroy(&ip6_dst_blackhole_ops);
3215out_kmem_cache:
3216        kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3217        goto out;
3218}
3219
3220void ip6_route_cleanup(void)
3221{
3222        unregister_netdevice_notifier(&ip6_route_dev_notifier);
3223        unregister_pernet_subsys(&ip6_route_net_late_ops);
3224        fib6_rules_cleanup();
3225        xfrm6_fini();
3226        fib6_gc_cleanup();
3227        unregister_pernet_subsys(&ipv6_inetpeer_ops);
3228        unregister_pernet_subsys(&ip6_route_net_ops);
3229        dst_entries_destroy(&ip6_dst_blackhole_ops);
3230        kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3231}
Note: See TracBrowser for help on using the repository browser.