2 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
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.
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.
24 * Fixed routing subtrees.
27 #define pr_fmt(fmt) "IPv6: " fmt
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>
50 #include <net/ip6_fib.h>
51 #include <net/ip6_route.h>
52 #include <net/ndisc.h>
53 #include <net/addrconf.h>
55 #include <linux/rtnetlink.h>
57 #include <net/dst_metadata.h>
59 #include <net/netevent.h>
60 #include <net/netlink.h>
61 #include <net/nexthop.h>
62 #include <net/lwtunnel.h>
63 #include <net/ip_tunnels.h>
64 #include <net/l3mdev.h>
65 #include <trace/events/fib6.h>
67 #include <linux/uaccess.h>
70 #include <linux/sysctl.h>
74 RT6_NUD_FAIL_HARD
= -3,
75 RT6_NUD_FAIL_PROBE
= -2,
76 RT6_NUD_FAIL_DO_RR
= -1,
80 static void ip6_rt_copy_init(struct rt6_info
*rt
, struct rt6_info
*ort
);
81 static struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
, u32 cookie
);
82 static unsigned int ip6_default_advmss(const struct dst_entry
*dst
);
83 static unsigned int ip6_mtu(const struct dst_entry
*dst
);
84 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*);
85 static void ip6_dst_destroy(struct dst_entry
*);
86 static void ip6_dst_ifdown(struct dst_entry
*,
87 struct net_device
*dev
, int how
);
88 static int ip6_dst_gc(struct dst_ops
*ops
);
90 static int ip6_pkt_discard(struct sk_buff
*skb
);
91 static int ip6_pkt_discard_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
);
92 static int ip6_pkt_prohibit(struct sk_buff
*skb
);
93 static int ip6_pkt_prohibit_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
);
94 static void ip6_link_failure(struct sk_buff
*skb
);
95 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
96 struct sk_buff
*skb
, u32 mtu
);
97 static void rt6_do_redirect(struct dst_entry
*dst
, struct sock
*sk
,
99 static void rt6_dst_from_metrics_check(struct rt6_info
*rt
);
100 static int rt6_score_route(struct rt6_info
*rt
, int oif
, int strict
);
101 static size_t rt6_nlmsg_size(struct rt6_info
*rt
);
102 static int rt6_fill_node(struct net
*net
,
103 struct sk_buff
*skb
, struct rt6_info
*rt
,
104 struct in6_addr
*dst
, struct in6_addr
*src
,
105 int iif
, int type
, u32 portid
, u32 seq
,
108 #ifdef CONFIG_IPV6_ROUTE_INFO
109 static struct rt6_info
*rt6_add_route_info(struct net
*net
,
110 const struct in6_addr
*prefix
, int prefixlen
,
111 const struct in6_addr
*gwaddr
,
112 struct net_device
*dev
,
114 static struct rt6_info
*rt6_get_route_info(struct net
*net
,
115 const struct in6_addr
*prefix
, int prefixlen
,
116 const struct in6_addr
*gwaddr
,
117 struct net_device
*dev
);
120 struct uncached_list
{
122 struct list_head head
;
125 static DEFINE_PER_CPU_ALIGNED(struct uncached_list
, rt6_uncached_list
);
127 static void rt6_uncached_list_add(struct rt6_info
*rt
)
129 struct uncached_list
*ul
= raw_cpu_ptr(&rt6_uncached_list
);
131 rt
->rt6i_uncached_list
= ul
;
133 spin_lock_bh(&ul
->lock
);
134 list_add_tail(&rt
->rt6i_uncached
, &ul
->head
);
135 spin_unlock_bh(&ul
->lock
);
138 static void rt6_uncached_list_del(struct rt6_info
*rt
)
140 if (!list_empty(&rt
->rt6i_uncached
)) {
141 struct uncached_list
*ul
= rt
->rt6i_uncached_list
;
143 spin_lock_bh(&ul
->lock
);
144 list_del(&rt
->rt6i_uncached
);
145 spin_unlock_bh(&ul
->lock
);
149 static void rt6_uncached_list_flush_dev(struct net
*net
, struct net_device
*dev
)
151 struct net_device
*loopback_dev
= net
->loopback_dev
;
154 if (dev
== loopback_dev
)
157 for_each_possible_cpu(cpu
) {
158 struct uncached_list
*ul
= per_cpu_ptr(&rt6_uncached_list
, cpu
);
161 spin_lock_bh(&ul
->lock
);
162 list_for_each_entry(rt
, &ul
->head
, rt6i_uncached
) {
163 struct inet6_dev
*rt_idev
= rt
->rt6i_idev
;
164 struct net_device
*rt_dev
= rt
->dst
.dev
;
166 if (rt_idev
->dev
== dev
) {
167 rt
->rt6i_idev
= in6_dev_get(loopback_dev
);
168 in6_dev_put(rt_idev
);
172 rt
->dst
.dev
= loopback_dev
;
173 dev_hold(rt
->dst
.dev
);
177 spin_unlock_bh(&ul
->lock
);
181 static u32
*rt6_pcpu_cow_metrics(struct rt6_info
*rt
)
183 return dst_metrics_write_ptr(rt
->dst
.from
);
186 static u32
*ipv6_cow_metrics(struct dst_entry
*dst
, unsigned long old
)
188 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
190 if (rt
->rt6i_flags
& RTF_PCPU
)
191 return rt6_pcpu_cow_metrics(rt
);
192 else if (rt
->rt6i_flags
& RTF_CACHE
)
195 return dst_cow_metrics_generic(dst
, old
);
198 static inline const void *choose_neigh_daddr(struct rt6_info
*rt
,
202 struct in6_addr
*p
= &rt
->rt6i_gateway
;
204 if (!ipv6_addr_any(p
))
205 return (const void *) p
;
207 return &ipv6_hdr(skb
)->daddr
;
211 static struct neighbour
*ip6_neigh_lookup(const struct dst_entry
*dst
,
215 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
218 daddr
= choose_neigh_daddr(rt
, skb
, daddr
);
219 n
= __ipv6_neigh_lookup(dst
->dev
, daddr
);
222 return neigh_create(&nd_tbl
, daddr
, dst
->dev
);
225 static void ip6_confirm_neigh(const struct dst_entry
*dst
, const void *daddr
)
227 struct net_device
*dev
= dst
->dev
;
228 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
230 daddr
= choose_neigh_daddr(rt
, NULL
, daddr
);
233 if (dev
->flags
& (IFF_NOARP
| IFF_LOOPBACK
))
235 if (ipv6_addr_is_multicast((const struct in6_addr
*)daddr
))
237 __ipv6_confirm_neigh(dev
, daddr
);
240 static struct dst_ops ip6_dst_ops_template
= {
244 .check
= ip6_dst_check
,
245 .default_advmss
= ip6_default_advmss
,
247 .cow_metrics
= ipv6_cow_metrics
,
248 .destroy
= ip6_dst_destroy
,
249 .ifdown
= ip6_dst_ifdown
,
250 .negative_advice
= ip6_negative_advice
,
251 .link_failure
= ip6_link_failure
,
252 .update_pmtu
= ip6_rt_update_pmtu
,
253 .redirect
= rt6_do_redirect
,
254 .local_out
= __ip6_local_out
,
255 .neigh_lookup
= ip6_neigh_lookup
,
256 .confirm_neigh
= ip6_confirm_neigh
,
259 static unsigned int ip6_blackhole_mtu(const struct dst_entry
*dst
)
261 unsigned int mtu
= dst_metric_raw(dst
, RTAX_MTU
);
263 return mtu
? : dst
->dev
->mtu
;
266 static void ip6_rt_blackhole_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
267 struct sk_buff
*skb
, u32 mtu
)
271 static void ip6_rt_blackhole_redirect(struct dst_entry
*dst
, struct sock
*sk
,
276 static struct dst_ops ip6_dst_blackhole_ops
= {
278 .destroy
= ip6_dst_destroy
,
279 .check
= ip6_dst_check
,
280 .mtu
= ip6_blackhole_mtu
,
281 .default_advmss
= ip6_default_advmss
,
282 .update_pmtu
= ip6_rt_blackhole_update_pmtu
,
283 .redirect
= ip6_rt_blackhole_redirect
,
284 .cow_metrics
= dst_cow_metrics_generic
,
285 .neigh_lookup
= ip6_neigh_lookup
,
288 static const u32 ip6_template_metrics
[RTAX_MAX
] = {
289 [RTAX_HOPLIMIT
- 1] = 0,
292 static const struct rt6_info ip6_null_entry_template
= {
294 .__refcnt
= ATOMIC_INIT(1),
296 .obsolete
= DST_OBSOLETE_FORCE_CHK
,
297 .error
= -ENETUNREACH
,
298 .input
= ip6_pkt_discard
,
299 .output
= ip6_pkt_discard_out
,
301 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
302 .rt6i_protocol
= RTPROT_KERNEL
,
303 .rt6i_metric
= ~(u32
) 0,
304 .rt6i_ref
= ATOMIC_INIT(1),
307 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
309 static const struct rt6_info ip6_prohibit_entry_template
= {
311 .__refcnt
= ATOMIC_INIT(1),
313 .obsolete
= DST_OBSOLETE_FORCE_CHK
,
315 .input
= ip6_pkt_prohibit
,
316 .output
= ip6_pkt_prohibit_out
,
318 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
319 .rt6i_protocol
= RTPROT_KERNEL
,
320 .rt6i_metric
= ~(u32
) 0,
321 .rt6i_ref
= ATOMIC_INIT(1),
324 static const struct rt6_info ip6_blk_hole_entry_template
= {
326 .__refcnt
= ATOMIC_INIT(1),
328 .obsolete
= DST_OBSOLETE_FORCE_CHK
,
330 .input
= dst_discard
,
331 .output
= dst_discard_out
,
333 .rt6i_flags
= (RTF_REJECT
| RTF_NONEXTHOP
),
334 .rt6i_protocol
= RTPROT_KERNEL
,
335 .rt6i_metric
= ~(u32
) 0,
336 .rt6i_ref
= ATOMIC_INIT(1),
341 static void rt6_info_init(struct rt6_info
*rt
)
343 struct dst_entry
*dst
= &rt
->dst
;
345 memset(dst
+ 1, 0, sizeof(*rt
) - sizeof(*dst
));
346 INIT_LIST_HEAD(&rt
->rt6i_siblings
);
347 INIT_LIST_HEAD(&rt
->rt6i_uncached
);
350 /* allocate dst with ip6_dst_ops */
351 static struct rt6_info
*__ip6_dst_alloc(struct net
*net
,
352 struct net_device
*dev
,
355 struct rt6_info
*rt
= dst_alloc(&net
->ipv6
.ip6_dst_ops
, dev
,
356 1, DST_OBSOLETE_FORCE_CHK
, flags
);
364 struct rt6_info
*ip6_dst_alloc(struct net
*net
,
365 struct net_device
*dev
,
368 struct rt6_info
*rt
= __ip6_dst_alloc(net
, dev
, flags
);
371 rt
->rt6i_pcpu
= alloc_percpu_gfp(struct rt6_info
*, GFP_ATOMIC
);
375 for_each_possible_cpu(cpu
) {
378 p
= per_cpu_ptr(rt
->rt6i_pcpu
, cpu
);
379 /* no one shares rt */
383 dst_release_immediate(&rt
->dst
);
390 EXPORT_SYMBOL(ip6_dst_alloc
);
392 static void ip6_dst_destroy(struct dst_entry
*dst
)
394 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
395 struct dst_entry
*from
= dst
->from
;
396 struct inet6_dev
*idev
;
398 dst_destroy_metrics_generic(dst
);
399 free_percpu(rt
->rt6i_pcpu
);
400 rt6_uncached_list_del(rt
);
402 idev
= rt
->rt6i_idev
;
404 rt
->rt6i_idev
= NULL
;
412 static void ip6_dst_ifdown(struct dst_entry
*dst
, struct net_device
*dev
,
415 struct rt6_info
*rt
= (struct rt6_info
*)dst
;
416 struct inet6_dev
*idev
= rt
->rt6i_idev
;
417 struct net_device
*loopback_dev
=
418 dev_net(dev
)->loopback_dev
;
420 if (dev
!= loopback_dev
) {
421 if (idev
&& idev
->dev
== dev
) {
422 struct inet6_dev
*loopback_idev
=
423 in6_dev_get(loopback_dev
);
425 rt
->rt6i_idev
= loopback_idev
;
432 static bool __rt6_check_expired(const struct rt6_info
*rt
)
434 if (rt
->rt6i_flags
& RTF_EXPIRES
)
435 return time_after(jiffies
, rt
->dst
.expires
);
440 static bool rt6_check_expired(const struct rt6_info
*rt
)
442 if (rt
->rt6i_flags
& RTF_EXPIRES
) {
443 if (time_after(jiffies
, rt
->dst
.expires
))
445 } else if (rt
->dst
.from
) {
446 return rt6_check_expired((struct rt6_info
*) rt
->dst
.from
);
451 /* Multipath route selection:
452 * Hash based function using packet header and flowlabel.
453 * Adapted from fib_info_hashfn()
455 static int rt6_info_hash_nhsfn(unsigned int candidate_count
,
456 const struct flowi6
*fl6
)
458 return get_hash_from_flowi6(fl6
) % candidate_count
;
461 static struct rt6_info
*rt6_multipath_select(struct rt6_info
*match
,
462 struct flowi6
*fl6
, int oif
,
465 struct rt6_info
*sibling
, *next_sibling
;
468 route_choosen
= rt6_info_hash_nhsfn(match
->rt6i_nsiblings
+ 1, fl6
);
469 /* Don't change the route, if route_choosen == 0
470 * (siblings does not include ourself)
473 list_for_each_entry_safe(sibling
, next_sibling
,
474 &match
->rt6i_siblings
, rt6i_siblings
) {
476 if (route_choosen
== 0) {
477 if (rt6_score_route(sibling
, oif
, strict
) < 0)
487 * Route lookup. Any table->tb6_lock is implied.
490 static inline struct rt6_info
*rt6_device_match(struct net
*net
,
492 const struct in6_addr
*saddr
,
496 struct rt6_info
*local
= NULL
;
497 struct rt6_info
*sprt
;
499 if (!oif
&& ipv6_addr_any(saddr
))
502 for (sprt
= rt
; sprt
; sprt
= sprt
->dst
.rt6_next
) {
503 struct net_device
*dev
= sprt
->dst
.dev
;
506 if (dev
->ifindex
== oif
)
508 if (dev
->flags
& IFF_LOOPBACK
) {
509 if (!sprt
->rt6i_idev
||
510 sprt
->rt6i_idev
->dev
->ifindex
!= oif
) {
511 if (flags
& RT6_LOOKUP_F_IFACE
)
514 local
->rt6i_idev
->dev
->ifindex
== oif
)
520 if (ipv6_chk_addr(net
, saddr
, dev
,
521 flags
& RT6_LOOKUP_F_IFACE
))
530 if (flags
& RT6_LOOKUP_F_IFACE
)
531 return net
->ipv6
.ip6_null_entry
;
537 #ifdef CONFIG_IPV6_ROUTER_PREF
538 struct __rt6_probe_work
{
539 struct work_struct work
;
540 struct in6_addr target
;
541 struct net_device
*dev
;
544 static void rt6_probe_deferred(struct work_struct
*w
)
546 struct in6_addr mcaddr
;
547 struct __rt6_probe_work
*work
=
548 container_of(w
, struct __rt6_probe_work
, work
);
550 addrconf_addr_solict_mult(&work
->target
, &mcaddr
);
551 ndisc_send_ns(work
->dev
, &work
->target
, &mcaddr
, NULL
, 0);
556 static void rt6_probe(struct rt6_info
*rt
)
558 struct __rt6_probe_work
*work
;
559 struct neighbour
*neigh
;
561 * Okay, this does not seem to be appropriate
562 * for now, however, we need to check if it
563 * is really so; aka Router Reachability Probing.
565 * Router Reachability Probe MUST be rate-limited
566 * to no more than one per minute.
568 if (!rt
|| !(rt
->rt6i_flags
& RTF_GATEWAY
))
571 neigh
= __ipv6_neigh_lookup_noref(rt
->dst
.dev
, &rt
->rt6i_gateway
);
573 if (neigh
->nud_state
& NUD_VALID
)
577 write_lock(&neigh
->lock
);
578 if (!(neigh
->nud_state
& NUD_VALID
) &&
581 rt
->rt6i_idev
->cnf
.rtr_probe_interval
)) {
582 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
584 __neigh_set_probe_once(neigh
);
586 write_unlock(&neigh
->lock
);
588 work
= kmalloc(sizeof(*work
), GFP_ATOMIC
);
592 INIT_WORK(&work
->work
, rt6_probe_deferred
);
593 work
->target
= rt
->rt6i_gateway
;
594 dev_hold(rt
->dst
.dev
);
595 work
->dev
= rt
->dst
.dev
;
596 schedule_work(&work
->work
);
600 rcu_read_unlock_bh();
603 static inline void rt6_probe(struct rt6_info
*rt
)
609 * Default Router Selection (RFC 2461 6.3.6)
611 static inline int rt6_check_dev(struct rt6_info
*rt
, int oif
)
613 struct net_device
*dev
= rt
->dst
.dev
;
614 if (!oif
|| dev
->ifindex
== oif
)
616 if ((dev
->flags
& IFF_LOOPBACK
) &&
617 rt
->rt6i_idev
&& rt
->rt6i_idev
->dev
->ifindex
== oif
)
622 static inline enum rt6_nud_state
rt6_check_neigh(struct rt6_info
*rt
)
624 struct neighbour
*neigh
;
625 enum rt6_nud_state ret
= RT6_NUD_FAIL_HARD
;
627 if (rt
->rt6i_flags
& RTF_NONEXTHOP
||
628 !(rt
->rt6i_flags
& RTF_GATEWAY
))
629 return RT6_NUD_SUCCEED
;
632 neigh
= __ipv6_neigh_lookup_noref(rt
->dst
.dev
, &rt
->rt6i_gateway
);
634 read_lock(&neigh
->lock
);
635 if (neigh
->nud_state
& NUD_VALID
)
636 ret
= RT6_NUD_SUCCEED
;
637 #ifdef CONFIG_IPV6_ROUTER_PREF
638 else if (!(neigh
->nud_state
& NUD_FAILED
))
639 ret
= RT6_NUD_SUCCEED
;
641 ret
= RT6_NUD_FAIL_PROBE
;
643 read_unlock(&neigh
->lock
);
645 ret
= IS_ENABLED(CONFIG_IPV6_ROUTER_PREF
) ?
646 RT6_NUD_SUCCEED
: RT6_NUD_FAIL_DO_RR
;
648 rcu_read_unlock_bh();
653 static int rt6_score_route(struct rt6_info
*rt
, int oif
,
658 m
= rt6_check_dev(rt
, oif
);
659 if (!m
&& (strict
& RT6_LOOKUP_F_IFACE
))
660 return RT6_NUD_FAIL_HARD
;
661 #ifdef CONFIG_IPV6_ROUTER_PREF
662 m
|= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt
->rt6i_flags
)) << 2;
664 if (strict
& RT6_LOOKUP_F_REACHABLE
) {
665 int n
= rt6_check_neigh(rt
);
672 static struct rt6_info
*find_match(struct rt6_info
*rt
, int oif
, int strict
,
673 int *mpri
, struct rt6_info
*match
,
677 bool match_do_rr
= false;
678 struct inet6_dev
*idev
= rt
->rt6i_idev
;
679 struct net_device
*dev
= rt
->dst
.dev
;
681 if (dev
&& !netif_carrier_ok(dev
) &&
682 idev
->cnf
.ignore_routes_with_linkdown
&&
683 !(strict
& RT6_LOOKUP_F_IGNORE_LINKSTATE
))
686 if (rt6_check_expired(rt
))
689 m
= rt6_score_route(rt
, oif
, strict
);
690 if (m
== RT6_NUD_FAIL_DO_RR
) {
692 m
= 0; /* lowest valid score */
693 } else if (m
== RT6_NUD_FAIL_HARD
) {
697 if (strict
& RT6_LOOKUP_F_REACHABLE
)
700 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
702 *do_rr
= match_do_rr
;
710 static struct rt6_info
*find_rr_leaf(struct fib6_node
*fn
,
711 struct rt6_info
*rr_head
,
712 u32 metric
, int oif
, int strict
,
715 struct rt6_info
*rt
, *match
, *cont
;
720 for (rt
= rr_head
; rt
; rt
= rt
->dst
.rt6_next
) {
721 if (rt
->rt6i_metric
!= metric
) {
726 match
= find_match(rt
, oif
, strict
, &mpri
, match
, do_rr
);
729 for (rt
= fn
->leaf
; rt
&& rt
!= rr_head
; rt
= rt
->dst
.rt6_next
) {
730 if (rt
->rt6i_metric
!= metric
) {
735 match
= find_match(rt
, oif
, strict
, &mpri
, match
, do_rr
);
741 for (rt
= cont
; rt
; rt
= rt
->dst
.rt6_next
)
742 match
= find_match(rt
, oif
, strict
, &mpri
, match
, do_rr
);
747 static struct rt6_info
*rt6_select(struct fib6_node
*fn
, int oif
, int strict
)
749 struct rt6_info
*match
, *rt0
;
755 fn
->rr_ptr
= rt0
= fn
->leaf
;
757 match
= find_rr_leaf(fn
, rt0
, rt0
->rt6i_metric
, oif
, strict
,
761 struct rt6_info
*next
= rt0
->dst
.rt6_next
;
763 /* no entries matched; do round-robin */
764 if (!next
|| next
->rt6i_metric
!= rt0
->rt6i_metric
)
771 net
= dev_net(rt0
->dst
.dev
);
772 return match
? match
: net
->ipv6
.ip6_null_entry
;
775 static bool rt6_is_gw_or_nonexthop(const struct rt6_info
*rt
)
777 return (rt
->rt6i_flags
& (RTF_NONEXTHOP
| RTF_GATEWAY
));
780 #ifdef CONFIG_IPV6_ROUTE_INFO
781 int rt6_route_rcv(struct net_device
*dev
, u8
*opt
, int len
,
782 const struct in6_addr
*gwaddr
)
784 struct net
*net
= dev_net(dev
);
785 struct route_info
*rinfo
= (struct route_info
*) opt
;
786 struct in6_addr prefix_buf
, *prefix
;
788 unsigned long lifetime
;
791 if (len
< sizeof(struct route_info
)) {
795 /* Sanity check for prefix_len and length */
796 if (rinfo
->length
> 3) {
798 } else if (rinfo
->prefix_len
> 128) {
800 } else if (rinfo
->prefix_len
> 64) {
801 if (rinfo
->length
< 2) {
804 } else if (rinfo
->prefix_len
> 0) {
805 if (rinfo
->length
< 1) {
810 pref
= rinfo
->route_pref
;
811 if (pref
== ICMPV6_ROUTER_PREF_INVALID
)
814 lifetime
= addrconf_timeout_fixup(ntohl(rinfo
->lifetime
), HZ
);
816 if (rinfo
->length
== 3)
817 prefix
= (struct in6_addr
*)rinfo
->prefix
;
819 /* this function is safe */
820 ipv6_addr_prefix(&prefix_buf
,
821 (struct in6_addr
*)rinfo
->prefix
,
823 prefix
= &prefix_buf
;
826 if (rinfo
->prefix_len
== 0)
827 rt
= rt6_get_dflt_router(gwaddr
, dev
);
829 rt
= rt6_get_route_info(net
, prefix
, rinfo
->prefix_len
,
832 if (rt
&& !lifetime
) {
838 rt
= rt6_add_route_info(net
, prefix
, rinfo
->prefix_len
, gwaddr
,
841 rt
->rt6i_flags
= RTF_ROUTEINFO
|
842 (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
845 if (!addrconf_finite_timeout(lifetime
))
846 rt6_clean_expires(rt
);
848 rt6_set_expires(rt
, jiffies
+ HZ
* lifetime
);
856 static struct fib6_node
* fib6_backtrack(struct fib6_node
*fn
,
857 struct in6_addr
*saddr
)
859 struct fib6_node
*pn
;
861 if (fn
->fn_flags
& RTN_TL_ROOT
)
864 if (FIB6_SUBTREE(pn
) && FIB6_SUBTREE(pn
) != fn
)
865 fn
= fib6_lookup(FIB6_SUBTREE(pn
), NULL
, saddr
);
868 if (fn
->fn_flags
& RTN_RTINFO
)
873 static struct rt6_info
*ip6_pol_route_lookup(struct net
*net
,
874 struct fib6_table
*table
,
875 struct flowi6
*fl6
, int flags
)
877 struct fib6_node
*fn
;
880 read_lock_bh(&table
->tb6_lock
);
881 fn
= fib6_lookup(&table
->tb6_root
, &fl6
->daddr
, &fl6
->saddr
);
884 rt
= rt6_device_match(net
, rt
, &fl6
->saddr
, fl6
->flowi6_oif
, flags
);
885 if (rt
->rt6i_nsiblings
&& fl6
->flowi6_oif
== 0)
886 rt
= rt6_multipath_select(rt
, fl6
, fl6
->flowi6_oif
, flags
);
887 if (rt
== net
->ipv6
.ip6_null_entry
) {
888 fn
= fib6_backtrack(fn
, &fl6
->saddr
);
892 dst_use(&rt
->dst
, jiffies
);
893 read_unlock_bh(&table
->tb6_lock
);
895 trace_fib6_table_lookup(net
, rt
, table
->tb6_id
, fl6
);
901 struct dst_entry
*ip6_route_lookup(struct net
*net
, struct flowi6
*fl6
,
904 return fib6_rule_lookup(net
, fl6
, flags
, ip6_pol_route_lookup
);
906 EXPORT_SYMBOL_GPL(ip6_route_lookup
);
908 struct rt6_info
*rt6_lookup(struct net
*net
, const struct in6_addr
*daddr
,
909 const struct in6_addr
*saddr
, int oif
, int strict
)
911 struct flowi6 fl6
= {
915 struct dst_entry
*dst
;
916 int flags
= strict
? RT6_LOOKUP_F_IFACE
: 0;
919 memcpy(&fl6
.saddr
, saddr
, sizeof(*saddr
));
920 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
923 dst
= fib6_rule_lookup(net
, &fl6
, flags
, ip6_pol_route_lookup
);
925 return (struct rt6_info
*) dst
;
931 EXPORT_SYMBOL(rt6_lookup
);
933 /* ip6_ins_rt is called with FREE table->tb6_lock.
934 * It takes new route entry, the addition fails by any reason the
936 * Caller must hold dst before calling it.
939 static int __ip6_ins_rt(struct rt6_info
*rt
, struct nl_info
*info
,
940 struct mx6_config
*mxc
,
941 struct netlink_ext_ack
*extack
)
944 struct fib6_table
*table
;
946 table
= rt
->rt6i_table
;
947 write_lock_bh(&table
->tb6_lock
);
948 err
= fib6_add(&table
->tb6_root
, rt
, info
, mxc
, extack
);
949 write_unlock_bh(&table
->tb6_lock
);
954 int ip6_ins_rt(struct rt6_info
*rt
)
956 struct nl_info info
= { .nl_net
= dev_net(rt
->dst
.dev
), };
957 struct mx6_config mxc
= { .mx
= NULL
, };
959 /* Hold dst to account for the reference from the fib6 tree */
961 return __ip6_ins_rt(rt
, &info
, &mxc
, NULL
);
964 static struct rt6_info
*ip6_rt_cache_alloc(struct rt6_info
*ort
,
965 const struct in6_addr
*daddr
,
966 const struct in6_addr
*saddr
)
974 if (ort
->rt6i_flags
& (RTF_CACHE
| RTF_PCPU
))
975 ort
= (struct rt6_info
*)ort
->dst
.from
;
977 rt
= __ip6_dst_alloc(dev_net(ort
->dst
.dev
), ort
->dst
.dev
, 0);
982 ip6_rt_copy_init(rt
, ort
);
983 rt
->rt6i_flags
|= RTF_CACHE
;
985 rt
->dst
.flags
|= DST_HOST
;
986 rt
->rt6i_dst
.addr
= *daddr
;
987 rt
->rt6i_dst
.plen
= 128;
989 if (!rt6_is_gw_or_nonexthop(ort
)) {
990 if (ort
->rt6i_dst
.plen
!= 128 &&
991 ipv6_addr_equal(&ort
->rt6i_dst
.addr
, daddr
))
992 rt
->rt6i_flags
|= RTF_ANYCAST
;
993 #ifdef CONFIG_IPV6_SUBTREES
994 if (rt
->rt6i_src
.plen
&& saddr
) {
995 rt
->rt6i_src
.addr
= *saddr
;
996 rt
->rt6i_src
.plen
= 128;
1004 static struct rt6_info
*ip6_rt_pcpu_alloc(struct rt6_info
*rt
)
1006 struct rt6_info
*pcpu_rt
;
1008 pcpu_rt
= __ip6_dst_alloc(dev_net(rt
->dst
.dev
),
1009 rt
->dst
.dev
, rt
->dst
.flags
);
1013 ip6_rt_copy_init(pcpu_rt
, rt
);
1014 pcpu_rt
->rt6i_protocol
= rt
->rt6i_protocol
;
1015 pcpu_rt
->rt6i_flags
|= RTF_PCPU
;
1019 /* It should be called with read_lock_bh(&tb6_lock) acquired */
1020 static struct rt6_info
*rt6_get_pcpu_route(struct rt6_info
*rt
)
1022 struct rt6_info
*pcpu_rt
, **p
;
1024 p
= this_cpu_ptr(rt
->rt6i_pcpu
);
1028 dst_hold(&pcpu_rt
->dst
);
1029 rt6_dst_from_metrics_check(pcpu_rt
);
1034 static struct rt6_info
*rt6_make_pcpu_route(struct rt6_info
*rt
)
1036 struct fib6_table
*table
= rt
->rt6i_table
;
1037 struct rt6_info
*pcpu_rt
, *prev
, **p
;
1039 pcpu_rt
= ip6_rt_pcpu_alloc(rt
);
1041 struct net
*net
= dev_net(rt
->dst
.dev
);
1043 dst_hold(&net
->ipv6
.ip6_null_entry
->dst
);
1044 return net
->ipv6
.ip6_null_entry
;
1047 read_lock_bh(&table
->tb6_lock
);
1048 if (rt
->rt6i_pcpu
) {
1049 p
= this_cpu_ptr(rt
->rt6i_pcpu
);
1050 prev
= cmpxchg(p
, NULL
, pcpu_rt
);
1052 /* If someone did it before us, return prev instead */
1053 dst_release_immediate(&pcpu_rt
->dst
);
1057 /* rt has been removed from the fib6 tree
1058 * before we have a chance to acquire the read_lock.
1059 * In this case, don't brother to create a pcpu rt
1060 * since rt is going away anyway. The next
1061 * dst_check() will trigger a re-lookup.
1063 dst_release_immediate(&pcpu_rt
->dst
);
1066 dst_hold(&pcpu_rt
->dst
);
1067 rt6_dst_from_metrics_check(pcpu_rt
);
1068 read_unlock_bh(&table
->tb6_lock
);
1072 struct rt6_info
*ip6_pol_route(struct net
*net
, struct fib6_table
*table
,
1073 int oif
, struct flowi6
*fl6
, int flags
)
1075 struct fib6_node
*fn
, *saved_fn
;
1076 struct rt6_info
*rt
;
1079 strict
|= flags
& RT6_LOOKUP_F_IFACE
;
1080 strict
|= flags
& RT6_LOOKUP_F_IGNORE_LINKSTATE
;
1081 if (net
->ipv6
.devconf_all
->forwarding
== 0)
1082 strict
|= RT6_LOOKUP_F_REACHABLE
;
1084 read_lock_bh(&table
->tb6_lock
);
1086 fn
= fib6_lookup(&table
->tb6_root
, &fl6
->daddr
, &fl6
->saddr
);
1089 if (fl6
->flowi6_flags
& FLOWI_FLAG_SKIP_NH_OIF
)
1093 rt
= rt6_select(fn
, oif
, strict
);
1094 if (rt
->rt6i_nsiblings
)
1095 rt
= rt6_multipath_select(rt
, fl6
, oif
, strict
);
1096 if (rt
== net
->ipv6
.ip6_null_entry
) {
1097 fn
= fib6_backtrack(fn
, &fl6
->saddr
);
1099 goto redo_rt6_select
;
1100 else if (strict
& RT6_LOOKUP_F_REACHABLE
) {
1101 /* also consider unreachable route */
1102 strict
&= ~RT6_LOOKUP_F_REACHABLE
;
1104 goto redo_rt6_select
;
1109 if (rt
== net
->ipv6
.ip6_null_entry
|| (rt
->rt6i_flags
& RTF_CACHE
)) {
1110 dst_use(&rt
->dst
, jiffies
);
1111 read_unlock_bh(&table
->tb6_lock
);
1113 rt6_dst_from_metrics_check(rt
);
1115 trace_fib6_table_lookup(net
, rt
, table
->tb6_id
, fl6
);
1117 } else if (unlikely((fl6
->flowi6_flags
& FLOWI_FLAG_KNOWN_NH
) &&
1118 !(rt
->rt6i_flags
& RTF_GATEWAY
))) {
1119 /* Create a RTF_CACHE clone which will not be
1120 * owned by the fib6 tree. It is for the special case where
1121 * the daddr in the skb during the neighbor look-up is different
1122 * from the fl6->daddr used to look-up route here.
1125 struct rt6_info
*uncached_rt
;
1127 dst_use(&rt
->dst
, jiffies
);
1128 read_unlock_bh(&table
->tb6_lock
);
1130 uncached_rt
= ip6_rt_cache_alloc(rt
, &fl6
->daddr
, NULL
);
1131 dst_release(&rt
->dst
);
1134 /* Uncached_rt's refcnt is taken during ip6_rt_cache_alloc()
1135 * No need for another dst_hold()
1137 rt6_uncached_list_add(uncached_rt
);
1139 uncached_rt
= net
->ipv6
.ip6_null_entry
;
1140 dst_hold(&uncached_rt
->dst
);
1143 trace_fib6_table_lookup(net
, uncached_rt
, table
->tb6_id
, fl6
);
1147 /* Get a percpu copy */
1149 struct rt6_info
*pcpu_rt
;
1151 rt
->dst
.lastuse
= jiffies
;
1153 pcpu_rt
= rt6_get_pcpu_route(rt
);
1156 read_unlock_bh(&table
->tb6_lock
);
1158 /* We have to do the read_unlock first
1159 * because rt6_make_pcpu_route() may trigger
1160 * ip6_dst_gc() which will take the write_lock.
1163 read_unlock_bh(&table
->tb6_lock
);
1164 pcpu_rt
= rt6_make_pcpu_route(rt
);
1165 dst_release(&rt
->dst
);
1168 trace_fib6_table_lookup(net
, pcpu_rt
, table
->tb6_id
, fl6
);
1173 EXPORT_SYMBOL_GPL(ip6_pol_route
);
1175 static struct rt6_info
*ip6_pol_route_input(struct net
*net
, struct fib6_table
*table
,
1176 struct flowi6
*fl6
, int flags
)
1178 return ip6_pol_route(net
, table
, fl6
->flowi6_iif
, fl6
, flags
);
1181 struct dst_entry
*ip6_route_input_lookup(struct net
*net
,
1182 struct net_device
*dev
,
1183 struct flowi6
*fl6
, int flags
)
1185 if (rt6_need_strict(&fl6
->daddr
) && dev
->type
!= ARPHRD_PIMREG
)
1186 flags
|= RT6_LOOKUP_F_IFACE
;
1188 return fib6_rule_lookup(net
, fl6
, flags
, ip6_pol_route_input
);
1190 EXPORT_SYMBOL_GPL(ip6_route_input_lookup
);
1192 void ip6_route_input(struct sk_buff
*skb
)
1194 const struct ipv6hdr
*iph
= ipv6_hdr(skb
);
1195 struct net
*net
= dev_net(skb
->dev
);
1196 int flags
= RT6_LOOKUP_F_HAS_SADDR
;
1197 struct ip_tunnel_info
*tun_info
;
1198 struct flowi6 fl6
= {
1199 .flowi6_iif
= skb
->dev
->ifindex
,
1200 .daddr
= iph
->daddr
,
1201 .saddr
= iph
->saddr
,
1202 .flowlabel
= ip6_flowinfo(iph
),
1203 .flowi6_mark
= skb
->mark
,
1204 .flowi6_proto
= iph
->nexthdr
,
1207 tun_info
= skb_tunnel_info(skb
);
1208 if (tun_info
&& !(tun_info
->mode
& IP_TUNNEL_INFO_TX
))
1209 fl6
.flowi6_tun_key
.tun_id
= tun_info
->key
.tun_id
;
1211 skb_dst_set(skb
, ip6_route_input_lookup(net
, skb
->dev
, &fl6
, flags
));
1214 static struct rt6_info
*ip6_pol_route_output(struct net
*net
, struct fib6_table
*table
,
1215 struct flowi6
*fl6
, int flags
)
1217 return ip6_pol_route(net
, table
, fl6
->flowi6_oif
, fl6
, flags
);
1220 struct dst_entry
*ip6_route_output_flags(struct net
*net
, const struct sock
*sk
,
1221 struct flowi6
*fl6
, int flags
)
1225 if (rt6_need_strict(&fl6
->daddr
)) {
1226 struct dst_entry
*dst
;
1228 dst
= l3mdev_link_scope_lookup(net
, fl6
);
1233 fl6
->flowi6_iif
= LOOPBACK_IFINDEX
;
1235 any_src
= ipv6_addr_any(&fl6
->saddr
);
1236 if ((sk
&& sk
->sk_bound_dev_if
) || rt6_need_strict(&fl6
->daddr
) ||
1237 (fl6
->flowi6_oif
&& any_src
))
1238 flags
|= RT6_LOOKUP_F_IFACE
;
1241 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
1243 flags
|= rt6_srcprefs2flags(inet6_sk(sk
)->srcprefs
);
1245 return fib6_rule_lookup(net
, fl6
, flags
, ip6_pol_route_output
);
1247 EXPORT_SYMBOL_GPL(ip6_route_output_flags
);
1249 struct dst_entry
*ip6_blackhole_route(struct net
*net
, struct dst_entry
*dst_orig
)
1251 struct rt6_info
*rt
, *ort
= (struct rt6_info
*) dst_orig
;
1252 struct net_device
*loopback_dev
= net
->loopback_dev
;
1253 struct dst_entry
*new = NULL
;
1255 rt
= dst_alloc(&ip6_dst_blackhole_ops
, loopback_dev
, 1,
1256 DST_OBSOLETE_NONE
, 0);
1262 new->input
= dst_discard
;
1263 new->output
= dst_discard_out
;
1265 dst_copy_metrics(new, &ort
->dst
);
1267 rt
->rt6i_idev
= in6_dev_get(loopback_dev
);
1268 rt
->rt6i_gateway
= ort
->rt6i_gateway
;
1269 rt
->rt6i_flags
= ort
->rt6i_flags
& ~RTF_PCPU
;
1270 rt
->rt6i_metric
= 0;
1272 memcpy(&rt
->rt6i_dst
, &ort
->rt6i_dst
, sizeof(struct rt6key
));
1273 #ifdef CONFIG_IPV6_SUBTREES
1274 memcpy(&rt
->rt6i_src
, &ort
->rt6i_src
, sizeof(struct rt6key
));
1278 dst_release(dst_orig
);
1279 return new ? new : ERR_PTR(-ENOMEM
);
1283 * Destination cache support functions
1286 static void rt6_dst_from_metrics_check(struct rt6_info
*rt
)
1289 dst_metrics_ptr(&rt
->dst
) != dst_metrics_ptr(rt
->dst
.from
))
1290 dst_init_metrics(&rt
->dst
, dst_metrics_ptr(rt
->dst
.from
), true);
1293 static struct dst_entry
*rt6_check(struct rt6_info
*rt
, u32 cookie
)
1295 if (!rt
->rt6i_node
|| (rt
->rt6i_node
->fn_sernum
!= cookie
))
1298 if (rt6_check_expired(rt
))
1304 static struct dst_entry
*rt6_dst_from_check(struct rt6_info
*rt
, u32 cookie
)
1306 if (!__rt6_check_expired(rt
) &&
1307 rt
->dst
.obsolete
== DST_OBSOLETE_FORCE_CHK
&&
1308 rt6_check((struct rt6_info
*)(rt
->dst
.from
), cookie
))
1314 static struct dst_entry
*ip6_dst_check(struct dst_entry
*dst
, u32 cookie
)
1316 struct rt6_info
*rt
;
1318 rt
= (struct rt6_info
*) dst
;
1320 /* All IPV6 dsts are created with ->obsolete set to the value
1321 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1322 * into this function always.
1325 rt6_dst_from_metrics_check(rt
);
1327 if (rt
->rt6i_flags
& RTF_PCPU
||
1328 (unlikely(!list_empty(&rt
->rt6i_uncached
)) && rt
->dst
.from
))
1329 return rt6_dst_from_check(rt
, cookie
);
1331 return rt6_check(rt
, cookie
);
1334 static struct dst_entry
*ip6_negative_advice(struct dst_entry
*dst
)
1336 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
1339 if (rt
->rt6i_flags
& RTF_CACHE
) {
1340 if (rt6_check_expired(rt
)) {
1352 static void ip6_link_failure(struct sk_buff
*skb
)
1354 struct rt6_info
*rt
;
1356 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_ADDR_UNREACH
, 0);
1358 rt
= (struct rt6_info
*) skb_dst(skb
);
1360 if (rt
->rt6i_flags
& RTF_CACHE
) {
1361 if (dst_hold_safe(&rt
->dst
))
1363 } else if (rt
->rt6i_node
&& (rt
->rt6i_flags
& RTF_DEFAULT
)) {
1364 rt
->rt6i_node
->fn_sernum
= -1;
1369 static void rt6_do_update_pmtu(struct rt6_info
*rt
, u32 mtu
)
1371 struct net
*net
= dev_net(rt
->dst
.dev
);
1373 rt
->rt6i_flags
|= RTF_MODIFIED
;
1374 rt
->rt6i_pmtu
= mtu
;
1375 rt6_update_expires(rt
, net
->ipv6
.sysctl
.ip6_rt_mtu_expires
);
1378 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info
*rt
)
1380 return !(rt
->rt6i_flags
& RTF_CACHE
) &&
1381 (rt
->rt6i_flags
& RTF_PCPU
|| rt
->rt6i_node
);
1384 static void __ip6_rt_update_pmtu(struct dst_entry
*dst
, const struct sock
*sk
,
1385 const struct ipv6hdr
*iph
, u32 mtu
)
1387 const struct in6_addr
*daddr
, *saddr
;
1388 struct rt6_info
*rt6
= (struct rt6_info
*)dst
;
1390 if (rt6
->rt6i_flags
& RTF_LOCAL
)
1393 if (dst_metric_locked(dst
, RTAX_MTU
))
1397 daddr
= &iph
->daddr
;
1398 saddr
= &iph
->saddr
;
1400 daddr
= &sk
->sk_v6_daddr
;
1401 saddr
= &inet6_sk(sk
)->saddr
;
1406 dst_confirm_neigh(dst
, daddr
);
1407 mtu
= max_t(u32
, mtu
, IPV6_MIN_MTU
);
1408 if (mtu
>= dst_mtu(dst
))
1411 if (!rt6_cache_allowed_for_pmtu(rt6
)) {
1412 rt6_do_update_pmtu(rt6
, mtu
);
1414 struct rt6_info
*nrt6
;
1416 nrt6
= ip6_rt_cache_alloc(rt6
, daddr
, saddr
);
1418 rt6_do_update_pmtu(nrt6
, mtu
);
1420 /* ip6_ins_rt(nrt6) will bump the
1421 * rt6->rt6i_node->fn_sernum
1422 * which will fail the next rt6_check() and
1423 * invalidate the sk->sk_dst_cache.
1426 /* Release the reference taken in
1427 * ip6_rt_cache_alloc()
1429 dst_release(&nrt6
->dst
);
1434 static void ip6_rt_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
1435 struct sk_buff
*skb
, u32 mtu
)
1437 __ip6_rt_update_pmtu(dst
, sk
, skb
? ipv6_hdr(skb
) : NULL
, mtu
);
1440 void ip6_update_pmtu(struct sk_buff
*skb
, struct net
*net
, __be32 mtu
,
1441 int oif
, u32 mark
, kuid_t uid
)
1443 const struct ipv6hdr
*iph
= (struct ipv6hdr
*) skb
->data
;
1444 struct dst_entry
*dst
;
1447 memset(&fl6
, 0, sizeof(fl6
));
1448 fl6
.flowi6_oif
= oif
;
1449 fl6
.flowi6_mark
= mark
? mark
: IP6_REPLY_MARK(net
, skb
->mark
);
1450 fl6
.daddr
= iph
->daddr
;
1451 fl6
.saddr
= iph
->saddr
;
1452 fl6
.flowlabel
= ip6_flowinfo(iph
);
1453 fl6
.flowi6_uid
= uid
;
1455 dst
= ip6_route_output(net
, NULL
, &fl6
);
1457 __ip6_rt_update_pmtu(dst
, NULL
, iph
, ntohl(mtu
));
1460 EXPORT_SYMBOL_GPL(ip6_update_pmtu
);
1462 void ip6_sk_update_pmtu(struct sk_buff
*skb
, struct sock
*sk
, __be32 mtu
)
1464 struct dst_entry
*dst
;
1466 ip6_update_pmtu(skb
, sock_net(sk
), mtu
,
1467 sk
->sk_bound_dev_if
, sk
->sk_mark
, sk
->sk_uid
);
1469 dst
= __sk_dst_get(sk
);
1470 if (!dst
|| !dst
->obsolete
||
1471 dst
->ops
->check(dst
, inet6_sk(sk
)->dst_cookie
))
1475 if (!sock_owned_by_user(sk
) && !ipv6_addr_v4mapped(&sk
->sk_v6_daddr
))
1476 ip6_datagram_dst_update(sk
, false);
1479 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu
);
1481 /* Handle redirects */
1482 struct ip6rd_flowi
{
1484 struct in6_addr gateway
;
1487 static struct rt6_info
*__ip6_route_redirect(struct net
*net
,
1488 struct fib6_table
*table
,
1492 struct ip6rd_flowi
*rdfl
= (struct ip6rd_flowi
*)fl6
;
1493 struct rt6_info
*rt
;
1494 struct fib6_node
*fn
;
1496 /* Get the "current" route for this destination and
1497 * check if the redirect has come from appropriate router.
1499 * RFC 4861 specifies that redirects should only be
1500 * accepted if they come from the nexthop to the target.
1501 * Due to the way the routes are chosen, this notion
1502 * is a bit fuzzy and one might need to check all possible
1506 read_lock_bh(&table
->tb6_lock
);
1507 fn
= fib6_lookup(&table
->tb6_root
, &fl6
->daddr
, &fl6
->saddr
);
1509 for (rt
= fn
->leaf
; rt
; rt
= rt
->dst
.rt6_next
) {
1510 if (rt6_check_expired(rt
))
1514 if (!(rt
->rt6i_flags
& RTF_GATEWAY
))
1516 if (fl6
->flowi6_oif
!= rt
->dst
.dev
->ifindex
)
1518 if (!ipv6_addr_equal(&rdfl
->gateway
, &rt
->rt6i_gateway
))
1524 rt
= net
->ipv6
.ip6_null_entry
;
1525 else if (rt
->dst
.error
) {
1526 rt
= net
->ipv6
.ip6_null_entry
;
1530 if (rt
== net
->ipv6
.ip6_null_entry
) {
1531 fn
= fib6_backtrack(fn
, &fl6
->saddr
);
1539 read_unlock_bh(&table
->tb6_lock
);
1541 trace_fib6_table_lookup(net
, rt
, table
->tb6_id
, fl6
);
1545 static struct dst_entry
*ip6_route_redirect(struct net
*net
,
1546 const struct flowi6
*fl6
,
1547 const struct in6_addr
*gateway
)
1549 int flags
= RT6_LOOKUP_F_HAS_SADDR
;
1550 struct ip6rd_flowi rdfl
;
1553 rdfl
.gateway
= *gateway
;
1555 return fib6_rule_lookup(net
, &rdfl
.fl6
,
1556 flags
, __ip6_route_redirect
);
1559 void ip6_redirect(struct sk_buff
*skb
, struct net
*net
, int oif
, u32 mark
,
1562 const struct ipv6hdr
*iph
= (struct ipv6hdr
*) skb
->data
;
1563 struct dst_entry
*dst
;
1566 memset(&fl6
, 0, sizeof(fl6
));
1567 fl6
.flowi6_iif
= LOOPBACK_IFINDEX
;
1568 fl6
.flowi6_oif
= oif
;
1569 fl6
.flowi6_mark
= mark
;
1570 fl6
.daddr
= iph
->daddr
;
1571 fl6
.saddr
= iph
->saddr
;
1572 fl6
.flowlabel
= ip6_flowinfo(iph
);
1573 fl6
.flowi6_uid
= uid
;
1575 dst
= ip6_route_redirect(net
, &fl6
, &ipv6_hdr(skb
)->saddr
);
1576 rt6_do_redirect(dst
, NULL
, skb
);
1579 EXPORT_SYMBOL_GPL(ip6_redirect
);
1581 void ip6_redirect_no_header(struct sk_buff
*skb
, struct net
*net
, int oif
,
1584 const struct ipv6hdr
*iph
= ipv6_hdr(skb
);
1585 const struct rd_msg
*msg
= (struct rd_msg
*)icmp6_hdr(skb
);
1586 struct dst_entry
*dst
;
1589 memset(&fl6
, 0, sizeof(fl6
));
1590 fl6
.flowi6_iif
= LOOPBACK_IFINDEX
;
1591 fl6
.flowi6_oif
= oif
;
1592 fl6
.flowi6_mark
= mark
;
1593 fl6
.daddr
= msg
->dest
;
1594 fl6
.saddr
= iph
->daddr
;
1595 fl6
.flowi6_uid
= sock_net_uid(net
, NULL
);
1597 dst
= ip6_route_redirect(net
, &fl6
, &iph
->saddr
);
1598 rt6_do_redirect(dst
, NULL
, skb
);
1602 void ip6_sk_redirect(struct sk_buff
*skb
, struct sock
*sk
)
1604 ip6_redirect(skb
, sock_net(sk
), sk
->sk_bound_dev_if
, sk
->sk_mark
,
1607 EXPORT_SYMBOL_GPL(ip6_sk_redirect
);
1609 static unsigned int ip6_default_advmss(const struct dst_entry
*dst
)
1611 struct net_device
*dev
= dst
->dev
;
1612 unsigned int mtu
= dst_mtu(dst
);
1613 struct net
*net
= dev_net(dev
);
1615 mtu
-= sizeof(struct ipv6hdr
) + sizeof(struct tcphdr
);
1617 if (mtu
< net
->ipv6
.sysctl
.ip6_rt_min_advmss
)
1618 mtu
= net
->ipv6
.sysctl
.ip6_rt_min_advmss
;
1621 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1622 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1623 * IPV6_MAXPLEN is also valid and means: "any MSS,
1624 * rely only on pmtu discovery"
1626 if (mtu
> IPV6_MAXPLEN
- sizeof(struct tcphdr
))
1631 static unsigned int ip6_mtu(const struct dst_entry
*dst
)
1633 const struct rt6_info
*rt
= (const struct rt6_info
*)dst
;
1634 unsigned int mtu
= rt
->rt6i_pmtu
;
1635 struct inet6_dev
*idev
;
1640 mtu
= dst_metric_raw(dst
, RTAX_MTU
);
1647 idev
= __in6_dev_get(dst
->dev
);
1649 mtu
= idev
->cnf
.mtu6
;
1653 mtu
= min_t(unsigned int, mtu
, IP6_MAX_MTU
);
1655 return mtu
- lwtunnel_headroom(dst
->lwtstate
, mtu
);
1658 struct dst_entry
*icmp6_dst_alloc(struct net_device
*dev
,
1661 struct dst_entry
*dst
;
1662 struct rt6_info
*rt
;
1663 struct inet6_dev
*idev
= in6_dev_get(dev
);
1664 struct net
*net
= dev_net(dev
);
1666 if (unlikely(!idev
))
1667 return ERR_PTR(-ENODEV
);
1669 rt
= ip6_dst_alloc(net
, dev
, 0);
1670 if (unlikely(!rt
)) {
1672 dst
= ERR_PTR(-ENOMEM
);
1676 rt
->dst
.flags
|= DST_HOST
;
1677 rt
->dst
.output
= ip6_output
;
1678 rt
->rt6i_gateway
= fl6
->daddr
;
1679 rt
->rt6i_dst
.addr
= fl6
->daddr
;
1680 rt
->rt6i_dst
.plen
= 128;
1681 rt
->rt6i_idev
= idev
;
1682 dst_metric_set(&rt
->dst
, RTAX_HOPLIMIT
, 0);
1684 /* Add this dst into uncached_list so that rt6_ifdown() can
1685 * do proper release of the net_device
1687 rt6_uncached_list_add(rt
);
1689 dst
= xfrm_lookup(net
, &rt
->dst
, flowi6_to_flowi(fl6
), NULL
, 0);
1695 static int ip6_dst_gc(struct dst_ops
*ops
)
1697 struct net
*net
= container_of(ops
, struct net
, ipv6
.ip6_dst_ops
);
1698 int rt_min_interval
= net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
;
1699 int rt_max_size
= net
->ipv6
.sysctl
.ip6_rt_max_size
;
1700 int rt_elasticity
= net
->ipv6
.sysctl
.ip6_rt_gc_elasticity
;
1701 int rt_gc_timeout
= net
->ipv6
.sysctl
.ip6_rt_gc_timeout
;
1702 unsigned long rt_last_gc
= net
->ipv6
.ip6_rt_last_gc
;
1705 entries
= dst_entries_get_fast(ops
);
1706 if (time_after(rt_last_gc
+ rt_min_interval
, jiffies
) &&
1707 entries
<= rt_max_size
)
1710 net
->ipv6
.ip6_rt_gc_expire
++;
1711 fib6_run_gc(net
->ipv6
.ip6_rt_gc_expire
, net
, true);
1712 entries
= dst_entries_get_slow(ops
);
1713 if (entries
< ops
->gc_thresh
)
1714 net
->ipv6
.ip6_rt_gc_expire
= rt_gc_timeout
>>1;
1716 net
->ipv6
.ip6_rt_gc_expire
-= net
->ipv6
.ip6_rt_gc_expire
>>rt_elasticity
;
1717 return entries
> rt_max_size
;
1720 static int ip6_convert_metrics(struct mx6_config
*mxc
,
1721 const struct fib6_config
*cfg
)
1723 bool ecn_ca
= false;
1731 mp
= kzalloc(sizeof(u32
) * RTAX_MAX
, GFP_KERNEL
);
1735 nla_for_each_attr(nla
, cfg
->fc_mx
, cfg
->fc_mx_len
, remaining
) {
1736 int type
= nla_type(nla
);
1741 if (unlikely(type
> RTAX_MAX
))
1744 if (type
== RTAX_CC_ALGO
) {
1745 char tmp
[TCP_CA_NAME_MAX
];
1747 nla_strlcpy(tmp
, nla
, sizeof(tmp
));
1748 val
= tcp_ca_get_key_by_name(tmp
, &ecn_ca
);
1749 if (val
== TCP_CA_UNSPEC
)
1752 val
= nla_get_u32(nla
);
1754 if (type
== RTAX_HOPLIMIT
&& val
> 255)
1756 if (type
== RTAX_FEATURES
&& (val
& ~RTAX_FEATURE_MASK
))
1760 __set_bit(type
- 1, mxc
->mx_valid
);
1764 __set_bit(RTAX_FEATURES
- 1, mxc
->mx_valid
);
1765 mp
[RTAX_FEATURES
- 1] |= DST_FEATURE_ECN_CA
;
1775 static struct rt6_info
*ip6_nh_lookup_table(struct net
*net
,
1776 struct fib6_config
*cfg
,
1777 const struct in6_addr
*gw_addr
)
1779 struct flowi6 fl6
= {
1780 .flowi6_oif
= cfg
->fc_ifindex
,
1782 .saddr
= cfg
->fc_prefsrc
,
1784 struct fib6_table
*table
;
1785 struct rt6_info
*rt
;
1786 int flags
= RT6_LOOKUP_F_IFACE
| RT6_LOOKUP_F_IGNORE_LINKSTATE
;
1788 table
= fib6_get_table(net
, cfg
->fc_table
);
1792 if (!ipv6_addr_any(&cfg
->fc_prefsrc
))
1793 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
1795 rt
= ip6_pol_route(net
, table
, cfg
->fc_ifindex
, &fl6
, flags
);
1797 /* if table lookup failed, fall back to full lookup */
1798 if (rt
== net
->ipv6
.ip6_null_entry
) {
1806 static struct rt6_info
*ip6_route_info_create(struct fib6_config
*cfg
,
1807 struct netlink_ext_ack
*extack
)
1809 struct net
*net
= cfg
->fc_nlinfo
.nl_net
;
1810 struct rt6_info
*rt
= NULL
;
1811 struct net_device
*dev
= NULL
;
1812 struct inet6_dev
*idev
= NULL
;
1813 struct fib6_table
*table
;
1817 /* RTF_PCPU is an internal flag; can not be set by userspace */
1818 if (cfg
->fc_flags
& RTF_PCPU
) {
1819 NL_SET_ERR_MSG(extack
, "Userspace can not set RTF_PCPU");
1823 if (cfg
->fc_dst_len
> 128) {
1824 NL_SET_ERR_MSG(extack
, "Invalid prefix length");
1827 if (cfg
->fc_src_len
> 128) {
1828 NL_SET_ERR_MSG(extack
, "Invalid source address length");
1831 #ifndef CONFIG_IPV6_SUBTREES
1832 if (cfg
->fc_src_len
) {
1833 NL_SET_ERR_MSG(extack
,
1834 "Specifying source address requires IPV6_SUBTREES to be enabled");
1838 if (cfg
->fc_ifindex
) {
1840 dev
= dev_get_by_index(net
, cfg
->fc_ifindex
);
1843 idev
= in6_dev_get(dev
);
1848 if (cfg
->fc_metric
== 0)
1849 cfg
->fc_metric
= IP6_RT_PRIO_USER
;
1852 if (cfg
->fc_nlinfo
.nlh
&&
1853 !(cfg
->fc_nlinfo
.nlh
->nlmsg_flags
& NLM_F_CREATE
)) {
1854 table
= fib6_get_table(net
, cfg
->fc_table
);
1856 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1857 table
= fib6_new_table(net
, cfg
->fc_table
);
1860 table
= fib6_new_table(net
, cfg
->fc_table
);
1866 rt
= ip6_dst_alloc(net
, NULL
,
1867 (cfg
->fc_flags
& RTF_ADDRCONF
) ? 0 : DST_NOCOUNT
);
1874 if (cfg
->fc_flags
& RTF_EXPIRES
)
1875 rt6_set_expires(rt
, jiffies
+
1876 clock_t_to_jiffies(cfg
->fc_expires
));
1878 rt6_clean_expires(rt
);
1880 if (cfg
->fc_protocol
== RTPROT_UNSPEC
)
1881 cfg
->fc_protocol
= RTPROT_BOOT
;
1882 rt
->rt6i_protocol
= cfg
->fc_protocol
;
1884 addr_type
= ipv6_addr_type(&cfg
->fc_dst
);
1886 if (addr_type
& IPV6_ADDR_MULTICAST
)
1887 rt
->dst
.input
= ip6_mc_input
;
1888 else if (cfg
->fc_flags
& RTF_LOCAL
)
1889 rt
->dst
.input
= ip6_input
;
1891 rt
->dst
.input
= ip6_forward
;
1893 rt
->dst
.output
= ip6_output
;
1895 if (cfg
->fc_encap
) {
1896 struct lwtunnel_state
*lwtstate
;
1898 err
= lwtunnel_build_state(cfg
->fc_encap_type
,
1899 cfg
->fc_encap
, AF_INET6
, cfg
,
1903 rt
->dst
.lwtstate
= lwtstate_get(lwtstate
);
1904 if (lwtunnel_output_redirect(rt
->dst
.lwtstate
)) {
1905 rt
->dst
.lwtstate
->orig_output
= rt
->dst
.output
;
1906 rt
->dst
.output
= lwtunnel_output
;
1908 if (lwtunnel_input_redirect(rt
->dst
.lwtstate
)) {
1909 rt
->dst
.lwtstate
->orig_input
= rt
->dst
.input
;
1910 rt
->dst
.input
= lwtunnel_input
;
1914 ipv6_addr_prefix(&rt
->rt6i_dst
.addr
, &cfg
->fc_dst
, cfg
->fc_dst_len
);
1915 rt
->rt6i_dst
.plen
= cfg
->fc_dst_len
;
1916 if (rt
->rt6i_dst
.plen
== 128)
1917 rt
->dst
.flags
|= DST_HOST
;
1919 #ifdef CONFIG_IPV6_SUBTREES
1920 ipv6_addr_prefix(&rt
->rt6i_src
.addr
, &cfg
->fc_src
, cfg
->fc_src_len
);
1921 rt
->rt6i_src
.plen
= cfg
->fc_src_len
;
1924 rt
->rt6i_metric
= cfg
->fc_metric
;
1926 /* We cannot add true routes via loopback here,
1927 they would result in kernel looping; promote them to reject routes
1929 if ((cfg
->fc_flags
& RTF_REJECT
) ||
1930 (dev
&& (dev
->flags
& IFF_LOOPBACK
) &&
1931 !(addr_type
& IPV6_ADDR_LOOPBACK
) &&
1932 !(cfg
->fc_flags
& RTF_LOCAL
))) {
1933 /* hold loopback dev/idev if we haven't done so. */
1934 if (dev
!= net
->loopback_dev
) {
1939 dev
= net
->loopback_dev
;
1941 idev
= in6_dev_get(dev
);
1947 rt
->rt6i_flags
= RTF_REJECT
|RTF_NONEXTHOP
;
1948 switch (cfg
->fc_type
) {
1950 rt
->dst
.error
= -EINVAL
;
1951 rt
->dst
.output
= dst_discard_out
;
1952 rt
->dst
.input
= dst_discard
;
1955 rt
->dst
.error
= -EACCES
;
1956 rt
->dst
.output
= ip6_pkt_prohibit_out
;
1957 rt
->dst
.input
= ip6_pkt_prohibit
;
1960 case RTN_UNREACHABLE
:
1962 rt
->dst
.error
= (cfg
->fc_type
== RTN_THROW
) ? -EAGAIN
1963 : (cfg
->fc_type
== RTN_UNREACHABLE
)
1964 ? -EHOSTUNREACH
: -ENETUNREACH
;
1965 rt
->dst
.output
= ip6_pkt_discard_out
;
1966 rt
->dst
.input
= ip6_pkt_discard
;
1972 if (cfg
->fc_flags
& RTF_GATEWAY
) {
1973 const struct in6_addr
*gw_addr
;
1976 gw_addr
= &cfg
->fc_gateway
;
1977 gwa_type
= ipv6_addr_type(gw_addr
);
1979 /* if gw_addr is local we will fail to detect this in case
1980 * address is still TENTATIVE (DAD in progress). rt6_lookup()
1981 * will return already-added prefix route via interface that
1982 * prefix route was assigned to, which might be non-loopback.
1985 if (ipv6_chk_addr_and_flags(net
, gw_addr
,
1986 gwa_type
& IPV6_ADDR_LINKLOCAL
?
1987 dev
: NULL
, 0, 0)) {
1988 NL_SET_ERR_MSG(extack
, "Invalid gateway address");
1991 rt
->rt6i_gateway
= *gw_addr
;
1993 if (gwa_type
!= (IPV6_ADDR_LINKLOCAL
|IPV6_ADDR_UNICAST
)) {
1994 struct rt6_info
*grt
= NULL
;
1996 /* IPv6 strictly inhibits using not link-local
1997 addresses as nexthop address.
1998 Otherwise, router will not able to send redirects.
1999 It is very good, but in some (rare!) circumstances
2000 (SIT, PtP, NBMA NOARP links) it is handy to allow
2001 some exceptions. --ANK
2002 We allow IPv4-mapped nexthops to support RFC4798-type
2005 if (!(gwa_type
& (IPV6_ADDR_UNICAST
|
2006 IPV6_ADDR_MAPPED
))) {
2007 NL_SET_ERR_MSG(extack
,
2008 "Invalid gateway address");
2012 if (cfg
->fc_table
) {
2013 grt
= ip6_nh_lookup_table(net
, cfg
, gw_addr
);
2016 if (grt
->rt6i_flags
& RTF_GATEWAY
||
2017 (dev
&& dev
!= grt
->dst
.dev
)) {
2025 grt
= rt6_lookup(net
, gw_addr
, NULL
,
2026 cfg
->fc_ifindex
, 1);
2028 err
= -EHOSTUNREACH
;
2032 if (dev
!= grt
->dst
.dev
) {
2038 idev
= grt
->rt6i_idev
;
2040 in6_dev_hold(grt
->rt6i_idev
);
2042 if (!(grt
->rt6i_flags
& RTF_GATEWAY
))
2051 NL_SET_ERR_MSG(extack
, "Egress device not specified");
2053 } else if (dev
->flags
& IFF_LOOPBACK
) {
2054 NL_SET_ERR_MSG(extack
,
2055 "Egress device can not be loopback device for this route");
2064 if (!ipv6_addr_any(&cfg
->fc_prefsrc
)) {
2065 if (!ipv6_chk_addr(net
, &cfg
->fc_prefsrc
, dev
, 0)) {
2066 NL_SET_ERR_MSG(extack
, "Invalid source address");
2070 rt
->rt6i_prefsrc
.addr
= cfg
->fc_prefsrc
;
2071 rt
->rt6i_prefsrc
.plen
= 128;
2073 rt
->rt6i_prefsrc
.plen
= 0;
2075 rt
->rt6i_flags
= cfg
->fc_flags
;
2079 rt
->rt6i_idev
= idev
;
2080 rt
->rt6i_table
= table
;
2082 cfg
->fc_nlinfo
.nl_net
= dev_net(dev
);
2091 dst_release_immediate(&rt
->dst
);
2093 return ERR_PTR(err
);
2096 int ip6_route_add(struct fib6_config
*cfg
,
2097 struct netlink_ext_ack
*extack
)
2099 struct mx6_config mxc
= { .mx
= NULL
, };
2100 struct rt6_info
*rt
;
2103 rt
= ip6_route_info_create(cfg
, extack
);
2110 err
= ip6_convert_metrics(&mxc
, cfg
);
2114 err
= __ip6_ins_rt(rt
, &cfg
->fc_nlinfo
, &mxc
, extack
);
2121 dst_release_immediate(&rt
->dst
);
2126 static int __ip6_del_rt(struct rt6_info
*rt
, struct nl_info
*info
)
2129 struct fib6_table
*table
;
2130 struct net
*net
= dev_net(rt
->dst
.dev
);
2132 if (rt
== net
->ipv6
.ip6_null_entry
) {
2137 table
= rt
->rt6i_table
;
2138 write_lock_bh(&table
->tb6_lock
);
2139 err
= fib6_del(rt
, info
);
2140 write_unlock_bh(&table
->tb6_lock
);
2147 int ip6_del_rt(struct rt6_info
*rt
)
2149 struct nl_info info
= {
2150 .nl_net
= dev_net(rt
->dst
.dev
),
2152 return __ip6_del_rt(rt
, &info
);
2155 static int __ip6_del_rt_siblings(struct rt6_info
*rt
, struct fib6_config
*cfg
)
2157 struct nl_info
*info
= &cfg
->fc_nlinfo
;
2158 struct net
*net
= info
->nl_net
;
2159 struct sk_buff
*skb
= NULL
;
2160 struct fib6_table
*table
;
2163 if (rt
== net
->ipv6
.ip6_null_entry
)
2165 table
= rt
->rt6i_table
;
2166 write_lock_bh(&table
->tb6_lock
);
2168 if (rt
->rt6i_nsiblings
&& cfg
->fc_delete_all_nh
) {
2169 struct rt6_info
*sibling
, *next_sibling
;
2171 /* prefer to send a single notification with all hops */
2172 skb
= nlmsg_new(rt6_nlmsg_size(rt
), gfp_any());
2174 u32 seq
= info
->nlh
? info
->nlh
->nlmsg_seq
: 0;
2176 if (rt6_fill_node(net
, skb
, rt
,
2177 NULL
, NULL
, 0, RTM_DELROUTE
,
2178 info
->portid
, seq
, 0) < 0) {
2182 info
->skip_notify
= 1;
2185 list_for_each_entry_safe(sibling
, next_sibling
,
2188 err
= fib6_del(sibling
, info
);
2194 err
= fib6_del(rt
, info
);
2196 write_unlock_bh(&table
->tb6_lock
);
2201 rtnl_notify(skb
, net
, info
->portid
, RTNLGRP_IPV6_ROUTE
,
2202 info
->nlh
, gfp_any());
2207 static int ip6_route_del(struct fib6_config
*cfg
,
2208 struct netlink_ext_ack
*extack
)
2210 struct fib6_table
*table
;
2211 struct fib6_node
*fn
;
2212 struct rt6_info
*rt
;
2215 table
= fib6_get_table(cfg
->fc_nlinfo
.nl_net
, cfg
->fc_table
);
2217 NL_SET_ERR_MSG(extack
, "FIB table does not exist");
2221 read_lock_bh(&table
->tb6_lock
);
2223 fn
= fib6_locate(&table
->tb6_root
,
2224 &cfg
->fc_dst
, cfg
->fc_dst_len
,
2225 &cfg
->fc_src
, cfg
->fc_src_len
);
2228 for (rt
= fn
->leaf
; rt
; rt
= rt
->dst
.rt6_next
) {
2229 if ((rt
->rt6i_flags
& RTF_CACHE
) &&
2230 !(cfg
->fc_flags
& RTF_CACHE
))
2232 if (cfg
->fc_ifindex
&&
2234 rt
->dst
.dev
->ifindex
!= cfg
->fc_ifindex
))
2236 if (cfg
->fc_flags
& RTF_GATEWAY
&&
2237 !ipv6_addr_equal(&cfg
->fc_gateway
, &rt
->rt6i_gateway
))
2239 if (cfg
->fc_metric
&& cfg
->fc_metric
!= rt
->rt6i_metric
)
2241 if (cfg
->fc_protocol
&& cfg
->fc_protocol
!= rt
->rt6i_protocol
)
2244 read_unlock_bh(&table
->tb6_lock
);
2246 /* if gateway was specified only delete the one hop */
2247 if (cfg
->fc_flags
& RTF_GATEWAY
)
2248 return __ip6_del_rt(rt
, &cfg
->fc_nlinfo
);
2250 return __ip6_del_rt_siblings(rt
, cfg
);
2253 read_unlock_bh(&table
->tb6_lock
);
2258 static void rt6_do_redirect(struct dst_entry
*dst
, struct sock
*sk
, struct sk_buff
*skb
)
2260 struct netevent_redirect netevent
;
2261 struct rt6_info
*rt
, *nrt
= NULL
;
2262 struct ndisc_options ndopts
;
2263 struct inet6_dev
*in6_dev
;
2264 struct neighbour
*neigh
;
2266 int optlen
, on_link
;
2269 optlen
= skb_tail_pointer(skb
) - skb_transport_header(skb
);
2270 optlen
-= sizeof(*msg
);
2273 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
2277 msg
= (struct rd_msg
*)icmp6_hdr(skb
);
2279 if (ipv6_addr_is_multicast(&msg
->dest
)) {
2280 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
2285 if (ipv6_addr_equal(&msg
->dest
, &msg
->target
)) {
2287 } else if (ipv6_addr_type(&msg
->target
) !=
2288 (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
2289 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
2293 in6_dev
= __in6_dev_get(skb
->dev
);
2296 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
)
2300 * The IP source address of the Redirect MUST be the same as the current
2301 * first-hop router for the specified ICMP Destination Address.
2304 if (!ndisc_parse_options(skb
->dev
, msg
->opt
, optlen
, &ndopts
)) {
2305 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2310 if (ndopts
.nd_opts_tgt_lladdr
) {
2311 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
2314 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2319 rt
= (struct rt6_info
*) dst
;
2320 if (rt
->rt6i_flags
& RTF_REJECT
) {
2321 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
2325 /* Redirect received -> path was valid.
2326 * Look, redirects are sent only in response to data packets,
2327 * so that this nexthop apparently is reachable. --ANK
2329 dst_confirm_neigh(&rt
->dst
, &ipv6_hdr(skb
)->saddr
);
2331 neigh
= __neigh_lookup(&nd_tbl
, &msg
->target
, skb
->dev
, 1);
2336 * We have finally decided to accept it.
2339 ndisc_update(skb
->dev
, neigh
, lladdr
, NUD_STALE
,
2340 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
2341 NEIGH_UPDATE_F_OVERRIDE
|
2342 (on_link
? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
2343 NEIGH_UPDATE_F_ISROUTER
)),
2344 NDISC_REDIRECT
, &ndopts
);
2346 nrt
= ip6_rt_cache_alloc(rt
, &msg
->dest
, NULL
);
2350 nrt
->rt6i_flags
= RTF_GATEWAY
|RTF_UP
|RTF_DYNAMIC
|RTF_CACHE
;
2352 nrt
->rt6i_flags
&= ~RTF_GATEWAY
;
2354 nrt
->rt6i_protocol
= RTPROT_REDIRECT
;
2355 nrt
->rt6i_gateway
= *(struct in6_addr
*)neigh
->primary_key
;
2357 if (ip6_ins_rt(nrt
))
2360 netevent
.old
= &rt
->dst
;
2361 netevent
.new = &nrt
->dst
;
2362 netevent
.daddr
= &msg
->dest
;
2363 netevent
.neigh
= neigh
;
2364 call_netevent_notifiers(NETEVENT_REDIRECT
, &netevent
);
2366 if (rt
->rt6i_flags
& RTF_CACHE
) {
2367 rt
= (struct rt6_info
*) dst_clone(&rt
->dst
);
2372 /* Release the reference taken in
2373 * ip6_rt_cache_alloc()
2375 dst_release(&nrt
->dst
);
2378 neigh_release(neigh
);
2382 * Misc support functions
2385 static void rt6_set_from(struct rt6_info
*rt
, struct rt6_info
*from
)
2387 BUG_ON(from
->dst
.from
);
2389 rt
->rt6i_flags
&= ~RTF_EXPIRES
;
2390 dst_hold(&from
->dst
);
2391 rt
->dst
.from
= &from
->dst
;
2392 dst_init_metrics(&rt
->dst
, dst_metrics_ptr(&from
->dst
), true);
2395 static void ip6_rt_copy_init(struct rt6_info
*rt
, struct rt6_info
*ort
)
2397 rt
->dst
.input
= ort
->dst
.input
;
2398 rt
->dst
.output
= ort
->dst
.output
;
2399 rt
->rt6i_dst
= ort
->rt6i_dst
;
2400 rt
->dst
.error
= ort
->dst
.error
;
2401 rt
->rt6i_idev
= ort
->rt6i_idev
;
2403 in6_dev_hold(rt
->rt6i_idev
);
2404 rt
->dst
.lastuse
= jiffies
;
2405 rt
->rt6i_gateway
= ort
->rt6i_gateway
;
2406 rt
->rt6i_flags
= ort
->rt6i_flags
;
2407 rt6_set_from(rt
, ort
);
2408 rt
->rt6i_metric
= ort
->rt6i_metric
;
2409 #ifdef CONFIG_IPV6_SUBTREES
2410 rt
->rt6i_src
= ort
->rt6i_src
;
2412 rt
->rt6i_prefsrc
= ort
->rt6i_prefsrc
;
2413 rt
->rt6i_table
= ort
->rt6i_table
;
2414 rt
->dst
.lwtstate
= lwtstate_get(ort
->dst
.lwtstate
);
2417 #ifdef CONFIG_IPV6_ROUTE_INFO
2418 static struct rt6_info
*rt6_get_route_info(struct net
*net
,
2419 const struct in6_addr
*prefix
, int prefixlen
,
2420 const struct in6_addr
*gwaddr
,
2421 struct net_device
*dev
)
2423 u32 tb_id
= l3mdev_fib_table(dev
) ? : RT6_TABLE_INFO
;
2424 int ifindex
= dev
->ifindex
;
2425 struct fib6_node
*fn
;
2426 struct rt6_info
*rt
= NULL
;
2427 struct fib6_table
*table
;
2429 table
= fib6_get_table(net
, tb_id
);
2433 read_lock_bh(&table
->tb6_lock
);
2434 fn
= fib6_locate(&table
->tb6_root
, prefix
, prefixlen
, NULL
, 0);
2438 for (rt
= fn
->leaf
; rt
; rt
= rt
->dst
.rt6_next
) {
2439 if (rt
->dst
.dev
->ifindex
!= ifindex
)
2441 if ((rt
->rt6i_flags
& (RTF_ROUTEINFO
|RTF_GATEWAY
)) != (RTF_ROUTEINFO
|RTF_GATEWAY
))
2443 if (!ipv6_addr_equal(&rt
->rt6i_gateway
, gwaddr
))
2449 read_unlock_bh(&table
->tb6_lock
);
2453 static struct rt6_info
*rt6_add_route_info(struct net
*net
,
2454 const struct in6_addr
*prefix
, int prefixlen
,
2455 const struct in6_addr
*gwaddr
,
2456 struct net_device
*dev
,
2459 struct fib6_config cfg
= {
2460 .fc_metric
= IP6_RT_PRIO_USER
,
2461 .fc_ifindex
= dev
->ifindex
,
2462 .fc_dst_len
= prefixlen
,
2463 .fc_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_ROUTEINFO
|
2464 RTF_UP
| RTF_PREF(pref
),
2465 .fc_protocol
= RTPROT_RA
,
2466 .fc_nlinfo
.portid
= 0,
2467 .fc_nlinfo
.nlh
= NULL
,
2468 .fc_nlinfo
.nl_net
= net
,
2471 cfg
.fc_table
= l3mdev_fib_table(dev
) ? : RT6_TABLE_INFO
,
2472 cfg
.fc_dst
= *prefix
;
2473 cfg
.fc_gateway
= *gwaddr
;
2475 /* We should treat it as a default route if prefix length is 0. */
2477 cfg
.fc_flags
|= RTF_DEFAULT
;
2479 ip6_route_add(&cfg
, NULL
);
2481 return rt6_get_route_info(net
, prefix
, prefixlen
, gwaddr
, dev
);
2485 struct rt6_info
*rt6_get_dflt_router(const struct in6_addr
*addr
, struct net_device
*dev
)
2487 u32 tb_id
= l3mdev_fib_table(dev
) ? : RT6_TABLE_DFLT
;
2488 struct rt6_info
*rt
;
2489 struct fib6_table
*table
;
2491 table
= fib6_get_table(dev_net(dev
), tb_id
);
2495 read_lock_bh(&table
->tb6_lock
);
2496 for (rt
= table
->tb6_root
.leaf
; rt
; rt
= rt
->dst
.rt6_next
) {
2497 if (dev
== rt
->dst
.dev
&&
2498 ((rt
->rt6i_flags
& (RTF_ADDRCONF
| RTF_DEFAULT
)) == (RTF_ADDRCONF
| RTF_DEFAULT
)) &&
2499 ipv6_addr_equal(&rt
->rt6i_gateway
, addr
))
2504 read_unlock_bh(&table
->tb6_lock
);
2508 struct rt6_info
*rt6_add_dflt_router(const struct in6_addr
*gwaddr
,
2509 struct net_device
*dev
,
2512 struct fib6_config cfg
= {
2513 .fc_table
= l3mdev_fib_table(dev
) ? : RT6_TABLE_DFLT
,
2514 .fc_metric
= IP6_RT_PRIO_USER
,
2515 .fc_ifindex
= dev
->ifindex
,
2516 .fc_flags
= RTF_GATEWAY
| RTF_ADDRCONF
| RTF_DEFAULT
|
2517 RTF_UP
| RTF_EXPIRES
| RTF_PREF(pref
),
2518 .fc_protocol
= RTPROT_RA
,
2519 .fc_nlinfo
.portid
= 0,
2520 .fc_nlinfo
.nlh
= NULL
,
2521 .fc_nlinfo
.nl_net
= dev_net(dev
),
2524 cfg
.fc_gateway
= *gwaddr
;
2526 if (!ip6_route_add(&cfg
, NULL
)) {
2527 struct fib6_table
*table
;
2529 table
= fib6_get_table(dev_net(dev
), cfg
.fc_table
);
2531 table
->flags
|= RT6_TABLE_HAS_DFLT_ROUTER
;
2534 return rt6_get_dflt_router(gwaddr
, dev
);
2537 static void __rt6_purge_dflt_routers(struct fib6_table
*table
)
2539 struct rt6_info
*rt
;
2542 read_lock_bh(&table
->tb6_lock
);
2543 for (rt
= table
->tb6_root
.leaf
; rt
; rt
= rt
->dst
.rt6_next
) {
2544 if (rt
->rt6i_flags
& (RTF_DEFAULT
| RTF_ADDRCONF
) &&
2545 (!rt
->rt6i_idev
|| rt
->rt6i_idev
->cnf
.accept_ra
!= 2)) {
2547 read_unlock_bh(&table
->tb6_lock
);
2552 read_unlock_bh(&table
->tb6_lock
);
2554 table
->flags
&= ~RT6_TABLE_HAS_DFLT_ROUTER
;
2557 void rt6_purge_dflt_routers(struct net
*net
)
2559 struct fib6_table
*table
;
2560 struct hlist_head
*head
;
2565 for (h
= 0; h
< FIB6_TABLE_HASHSZ
; h
++) {
2566 head
= &net
->ipv6
.fib_table_hash
[h
];
2567 hlist_for_each_entry_rcu(table
, head
, tb6_hlist
) {
2568 if (table
->flags
& RT6_TABLE_HAS_DFLT_ROUTER
)
2569 __rt6_purge_dflt_routers(table
);
2576 static void rtmsg_to_fib6_config(struct net
*net
,
2577 struct in6_rtmsg
*rtmsg
,
2578 struct fib6_config
*cfg
)
2580 memset(cfg
, 0, sizeof(*cfg
));
2582 cfg
->fc_table
= l3mdev_fib_table_by_index(net
, rtmsg
->rtmsg_ifindex
) ?
2584 cfg
->fc_ifindex
= rtmsg
->rtmsg_ifindex
;
2585 cfg
->fc_metric
= rtmsg
->rtmsg_metric
;
2586 cfg
->fc_expires
= rtmsg
->rtmsg_info
;
2587 cfg
->fc_dst_len
= rtmsg
->rtmsg_dst_len
;
2588 cfg
->fc_src_len
= rtmsg
->rtmsg_src_len
;
2589 cfg
->fc_flags
= rtmsg
->rtmsg_flags
;
2591 cfg
->fc_nlinfo
.nl_net
= net
;
2593 cfg
->fc_dst
= rtmsg
->rtmsg_dst
;
2594 cfg
->fc_src
= rtmsg
->rtmsg_src
;
2595 cfg
->fc_gateway
= rtmsg
->rtmsg_gateway
;
2598 int ipv6_route_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
2600 struct fib6_config cfg
;
2601 struct in6_rtmsg rtmsg
;
2605 case SIOCADDRT
: /* Add a route */
2606 case SIOCDELRT
: /* Delete a route */
2607 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
2609 err
= copy_from_user(&rtmsg
, arg
,
2610 sizeof(struct in6_rtmsg
));
2614 rtmsg_to_fib6_config(net
, &rtmsg
, &cfg
);
2619 err
= ip6_route_add(&cfg
, NULL
);
2622 err
= ip6_route_del(&cfg
, NULL
);
2636 * Drop the packet on the floor
2639 static int ip6_pkt_drop(struct sk_buff
*skb
, u8 code
, int ipstats_mib_noroutes
)
2642 struct dst_entry
*dst
= skb_dst(skb
);
2643 switch (ipstats_mib_noroutes
) {
2644 case IPSTATS_MIB_INNOROUTES
:
2645 type
= ipv6_addr_type(&ipv6_hdr(skb
)->daddr
);
2646 if (type
== IPV6_ADDR_ANY
) {
2647 IP6_INC_STATS(dev_net(dst
->dev
), ip6_dst_idev(dst
),
2648 IPSTATS_MIB_INADDRERRORS
);
2652 case IPSTATS_MIB_OUTNOROUTES
:
2653 IP6_INC_STATS(dev_net(dst
->dev
), ip6_dst_idev(dst
),
2654 ipstats_mib_noroutes
);
2657 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, code
, 0);
2662 static int ip6_pkt_discard(struct sk_buff
*skb
)
2664 return ip6_pkt_drop(skb
, ICMPV6_NOROUTE
, IPSTATS_MIB_INNOROUTES
);
2667 static int ip6_pkt_discard_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
)
2669 skb
->dev
= skb_dst(skb
)->dev
;
2670 return ip6_pkt_drop(skb
, ICMPV6_NOROUTE
, IPSTATS_MIB_OUTNOROUTES
);
2673 static int ip6_pkt_prohibit(struct sk_buff
*skb
)
2675 return ip6_pkt_drop(skb
, ICMPV6_ADM_PROHIBITED
, IPSTATS_MIB_INNOROUTES
);
2678 static int ip6_pkt_prohibit_out(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
)
2680 skb
->dev
= skb_dst(skb
)->dev
;
2681 return ip6_pkt_drop(skb
, ICMPV6_ADM_PROHIBITED
, IPSTATS_MIB_OUTNOROUTES
);
2685 * Allocate a dst for local (unicast / anycast) address.
2688 struct rt6_info
*addrconf_dst_alloc(struct inet6_dev
*idev
,
2689 const struct in6_addr
*addr
,
2693 struct net
*net
= dev_net(idev
->dev
);
2694 struct net_device
*dev
= net
->loopback_dev
;
2695 struct rt6_info
*rt
;
2697 /* use L3 Master device as loopback for host routes if device
2698 * is enslaved and address is not link local or multicast
2700 if (!rt6_need_strict(addr
))
2701 dev
= l3mdev_master_dev_rcu(idev
->dev
) ? : dev
;
2703 rt
= ip6_dst_alloc(net
, dev
, DST_NOCOUNT
);
2705 return ERR_PTR(-ENOMEM
);
2709 rt
->dst
.flags
|= DST_HOST
;
2710 rt
->dst
.input
= ip6_input
;
2711 rt
->dst
.output
= ip6_output
;
2712 rt
->rt6i_idev
= idev
;
2714 rt
->rt6i_protocol
= RTPROT_KERNEL
;
2715 rt
->rt6i_flags
= RTF_UP
| RTF_NONEXTHOP
;
2717 rt
->rt6i_flags
|= RTF_ANYCAST
;
2719 rt
->rt6i_flags
|= RTF_LOCAL
;
2721 rt
->rt6i_gateway
= *addr
;
2722 rt
->rt6i_dst
.addr
= *addr
;
2723 rt
->rt6i_dst
.plen
= 128;
2724 tb_id
= l3mdev_fib_table(idev
->dev
) ? : RT6_TABLE_LOCAL
;
2725 rt
->rt6i_table
= fib6_get_table(net
, tb_id
);
2730 /* remove deleted ip from prefsrc entries */
2731 struct arg_dev_net_ip
{
2732 struct net_device
*dev
;
2734 struct in6_addr
*addr
;
2737 static int fib6_remove_prefsrc(struct rt6_info
*rt
, void *arg
)
2739 struct net_device
*dev
= ((struct arg_dev_net_ip
*)arg
)->dev
;
2740 struct net
*net
= ((struct arg_dev_net_ip
*)arg
)->net
;
2741 struct in6_addr
*addr
= ((struct arg_dev_net_ip
*)arg
)->addr
;
2743 if (((void *)rt
->dst
.dev
== dev
|| !dev
) &&
2744 rt
!= net
->ipv6
.ip6_null_entry
&&
2745 ipv6_addr_equal(addr
, &rt
->rt6i_prefsrc
.addr
)) {
2746 /* remove prefsrc entry */
2747 rt
->rt6i_prefsrc
.plen
= 0;
2752 void rt6_remove_prefsrc(struct inet6_ifaddr
*ifp
)
2754 struct net
*net
= dev_net(ifp
->idev
->dev
);
2755 struct arg_dev_net_ip adni
= {
2756 .dev
= ifp
->idev
->dev
,
2760 fib6_clean_all(net
, fib6_remove_prefsrc
, &adni
);
2763 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2764 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2766 /* Remove routers and update dst entries when gateway turn into host. */
2767 static int fib6_clean_tohost(struct rt6_info
*rt
, void *arg
)
2769 struct in6_addr
*gateway
= (struct in6_addr
*)arg
;
2771 if ((((rt
->rt6i_flags
& RTF_RA_ROUTER
) == RTF_RA_ROUTER
) ||
2772 ((rt
->rt6i_flags
& RTF_CACHE_GATEWAY
) == RTF_CACHE_GATEWAY
)) &&
2773 ipv6_addr_equal(gateway
, &rt
->rt6i_gateway
)) {
2779 void rt6_clean_tohost(struct net
*net
, struct in6_addr
*gateway
)
2781 fib6_clean_all(net
, fib6_clean_tohost
, gateway
);
2784 struct arg_dev_net
{
2785 struct net_device
*dev
;
2789 /* called with write lock held for table with rt */
2790 static int fib6_ifdown(struct rt6_info
*rt
, void *arg
)
2792 const struct arg_dev_net
*adn
= arg
;
2793 const struct net_device
*dev
= adn
->dev
;
2795 if ((rt
->dst
.dev
== dev
|| !dev
) &&
2796 rt
!= adn
->net
->ipv6
.ip6_null_entry
&&
2797 (rt
->rt6i_nsiblings
== 0 ||
2798 (dev
&& netdev_unregistering(dev
)) ||
2799 !rt
->rt6i_idev
->cnf
.ignore_routes_with_linkdown
))
2805 void rt6_ifdown(struct net
*net
, struct net_device
*dev
)
2807 struct arg_dev_net adn
= {
2812 fib6_clean_all(net
, fib6_ifdown
, &adn
);
2814 rt6_uncached_list_flush_dev(net
, dev
);
2817 struct rt6_mtu_change_arg
{
2818 struct net_device
*dev
;
2822 static int rt6_mtu_change_route(struct rt6_info
*rt
, void *p_arg
)
2824 struct rt6_mtu_change_arg
*arg
= (struct rt6_mtu_change_arg
*) p_arg
;
2825 struct inet6_dev
*idev
;
2827 /* In IPv6 pmtu discovery is not optional,
2828 so that RTAX_MTU lock cannot disable it.
2829 We still use this lock to block changes
2830 caused by addrconf/ndisc.
2833 idev
= __in6_dev_get(arg
->dev
);
2837 /* For administrative MTU increase, there is no way to discover
2838 IPv6 PMTU increase, so PMTU increase should be updated here.
2839 Since RFC 1981 doesn't include administrative MTU increase
2840 update PMTU increase is a MUST. (i.e. jumbo frame)
2843 If new MTU is less than route PMTU, this new MTU will be the
2844 lowest MTU in the path, update the route PMTU to reflect PMTU
2845 decreases; if new MTU is greater than route PMTU, and the
2846 old MTU is the lowest MTU in the path, update the route PMTU
2847 to reflect the increase. In this case if the other nodes' MTU
2848 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2851 if (rt
->dst
.dev
== arg
->dev
&&
2852 dst_metric_raw(&rt
->dst
, RTAX_MTU
) &&
2853 !dst_metric_locked(&rt
->dst
, RTAX_MTU
)) {
2854 if (rt
->rt6i_flags
& RTF_CACHE
) {
2855 /* For RTF_CACHE with rt6i_pmtu == 0
2856 * (i.e. a redirected route),
2857 * the metrics of its rt->dst.from has already
2860 if (rt
->rt6i_pmtu
&& rt
->rt6i_pmtu
> arg
->mtu
)
2861 rt
->rt6i_pmtu
= arg
->mtu
;
2862 } else if (dst_mtu(&rt
->dst
) >= arg
->mtu
||
2863 (dst_mtu(&rt
->dst
) < arg
->mtu
&&
2864 dst_mtu(&rt
->dst
) == idev
->cnf
.mtu6
)) {
2865 dst_metric_set(&rt
->dst
, RTAX_MTU
, arg
->mtu
);
2871 void rt6_mtu_change(struct net_device
*dev
, unsigned int mtu
)
2873 struct rt6_mtu_change_arg arg
= {
2878 fib6_clean_all(dev_net(dev
), rt6_mtu_change_route
, &arg
);
2881 static const struct nla_policy rtm_ipv6_policy
[RTA_MAX
+1] = {
2882 [RTA_GATEWAY
] = { .len
= sizeof(struct in6_addr
) },
2883 [RTA_OIF
] = { .type
= NLA_U32
},
2884 [RTA_IIF
] = { .type
= NLA_U32
},
2885 [RTA_PRIORITY
] = { .type
= NLA_U32
},
2886 [RTA_METRICS
] = { .type
= NLA_NESTED
},
2887 [RTA_MULTIPATH
] = { .len
= sizeof(struct rtnexthop
) },
2888 [RTA_PREF
] = { .type
= NLA_U8
},
2889 [RTA_ENCAP_TYPE
] = { .type
= NLA_U16
},
2890 [RTA_ENCAP
] = { .type
= NLA_NESTED
},
2891 [RTA_EXPIRES
] = { .type
= NLA_U32
},
2892 [RTA_UID
] = { .type
= NLA_U32
},
2893 [RTA_MARK
] = { .type
= NLA_U32
},
2896 static int rtm_to_fib6_config(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
2897 struct fib6_config
*cfg
,
2898 struct netlink_ext_ack
*extack
)
2901 struct nlattr
*tb
[RTA_MAX
+1];
2905 err
= nlmsg_parse(nlh
, sizeof(*rtm
), tb
, RTA_MAX
, rtm_ipv6_policy
,
2911 rtm
= nlmsg_data(nlh
);
2912 memset(cfg
, 0, sizeof(*cfg
));
2914 cfg
->fc_table
= rtm
->rtm_table
;
2915 cfg
->fc_dst_len
= rtm
->rtm_dst_len
;
2916 cfg
->fc_src_len
= rtm
->rtm_src_len
;
2917 cfg
->fc_flags
= RTF_UP
;
2918 cfg
->fc_protocol
= rtm
->rtm_protocol
;
2919 cfg
->fc_type
= rtm
->rtm_type
;
2921 if (rtm
->rtm_type
== RTN_UNREACHABLE
||
2922 rtm
->rtm_type
== RTN_BLACKHOLE
||
2923 rtm
->rtm_type
== RTN_PROHIBIT
||
2924 rtm
->rtm_type
== RTN_THROW
)
2925 cfg
->fc_flags
|= RTF_REJECT
;
2927 if (rtm
->rtm_type
== RTN_LOCAL
)
2928 cfg
->fc_flags
|= RTF_LOCAL
;
2930 if (rtm
->rtm_flags
& RTM_F_CLONED
)
2931 cfg
->fc_flags
|= RTF_CACHE
;
2933 cfg
->fc_nlinfo
.portid
= NETLINK_CB(skb
).portid
;
2934 cfg
->fc_nlinfo
.nlh
= nlh
;
2935 cfg
->fc_nlinfo
.nl_net
= sock_net(skb
->sk
);
2937 if (tb
[RTA_GATEWAY
]) {
2938 cfg
->fc_gateway
= nla_get_in6_addr(tb
[RTA_GATEWAY
]);
2939 cfg
->fc_flags
|= RTF_GATEWAY
;
2943 int plen
= (rtm
->rtm_dst_len
+ 7) >> 3;
2945 if (nla_len(tb
[RTA_DST
]) < plen
)
2948 nla_memcpy(&cfg
->fc_dst
, tb
[RTA_DST
], plen
);
2952 int plen
= (rtm
->rtm_src_len
+ 7) >> 3;
2954 if (nla_len(tb
[RTA_SRC
]) < plen
)
2957 nla_memcpy(&cfg
->fc_src
, tb
[RTA_SRC
], plen
);
2960 if (tb
[RTA_PREFSRC
])
2961 cfg
->fc_prefsrc
= nla_get_in6_addr(tb
[RTA_PREFSRC
]);
2964 cfg
->fc_ifindex
= nla_get_u32(tb
[RTA_OIF
]);
2966 if (tb
[RTA_PRIORITY
])
2967 cfg
->fc_metric
= nla_get_u32(tb
[RTA_PRIORITY
]);
2969 if (tb
[RTA_METRICS
]) {
2970 cfg
->fc_mx
= nla_data(tb
[RTA_METRICS
]);
2971 cfg
->fc_mx_len
= nla_len(tb
[RTA_METRICS
]);
2975 cfg
->fc_table
= nla_get_u32(tb
[RTA_TABLE
]);
2977 if (tb
[RTA_MULTIPATH
]) {
2978 cfg
->fc_mp
= nla_data(tb
[RTA_MULTIPATH
]);
2979 cfg
->fc_mp_len
= nla_len(tb
[RTA_MULTIPATH
]);
2981 err
= lwtunnel_valid_encap_type_attr(cfg
->fc_mp
,
2982 cfg
->fc_mp_len
, extack
);
2988 pref
= nla_get_u8(tb
[RTA_PREF
]);
2989 if (pref
!= ICMPV6_ROUTER_PREF_LOW
&&
2990 pref
!= ICMPV6_ROUTER_PREF_HIGH
)
2991 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
2992 cfg
->fc_flags
|= RTF_PREF(pref
);
2996 cfg
->fc_encap
= tb
[RTA_ENCAP
];
2998 if (tb
[RTA_ENCAP_TYPE
]) {
2999 cfg
->fc_encap_type
= nla_get_u16(tb
[RTA_ENCAP_TYPE
]);
3001 err
= lwtunnel_valid_encap_type(cfg
->fc_encap_type
, extack
);
3006 if (tb
[RTA_EXPIRES
]) {
3007 unsigned long timeout
= addrconf_timeout_fixup(nla_get_u32(tb
[RTA_EXPIRES
]), HZ
);
3009 if (addrconf_finite_timeout(timeout
)) {
3010 cfg
->fc_expires
= jiffies_to_clock_t(timeout
* HZ
);
3011 cfg
->fc_flags
|= RTF_EXPIRES
;
3021 struct rt6_info
*rt6_info
;
3022 struct fib6_config r_cfg
;
3023 struct mx6_config mxc
;
3024 struct list_head next
;
3027 static void ip6_print_replace_route_err(struct list_head
*rt6_nh_list
)
3031 list_for_each_entry(nh
, rt6_nh_list
, next
) {
3032 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
3033 &nh
->r_cfg
.fc_dst
, &nh
->r_cfg
.fc_gateway
,
3034 nh
->r_cfg
.fc_ifindex
);
3038 static int ip6_route_info_append(struct list_head
*rt6_nh_list
,
3039 struct rt6_info
*rt
, struct fib6_config
*r_cfg
)
3044 list_for_each_entry(nh
, rt6_nh_list
, next
) {
3045 /* check if rt6_info already exists */
3046 if (rt6_duplicate_nexthop(nh
->rt6_info
, rt
))
3050 nh
= kzalloc(sizeof(*nh
), GFP_KERNEL
);
3054 err
= ip6_convert_metrics(&nh
->mxc
, r_cfg
);
3059 memcpy(&nh
->r_cfg
, r_cfg
, sizeof(*r_cfg
));
3060 list_add_tail(&nh
->next
, rt6_nh_list
);
3065 static void ip6_route_mpath_notify(struct rt6_info
*rt
,
3066 struct rt6_info
*rt_last
,
3067 struct nl_info
*info
,
3070 /* if this is an APPEND route, then rt points to the first route
3071 * inserted and rt_last points to last route inserted. Userspace
3072 * wants a consistent dump of the route which starts at the first
3073 * nexthop. Since sibling routes are always added at the end of
3074 * the list, find the first sibling of the last route appended
3076 if ((nlflags
& NLM_F_APPEND
) && rt_last
&& rt_last
->rt6i_nsiblings
) {
3077 rt
= list_first_entry(&rt_last
->rt6i_siblings
,
3083 inet6_rt_notify(RTM_NEWROUTE
, rt
, info
, nlflags
);
3086 static int ip6_route_multipath_add(struct fib6_config
*cfg
,
3087 struct netlink_ext_ack
*extack
)
3089 struct rt6_info
*rt_notif
= NULL
, *rt_last
= NULL
;
3090 struct nl_info
*info
= &cfg
->fc_nlinfo
;
3091 struct fib6_config r_cfg
;
3092 struct rtnexthop
*rtnh
;
3093 struct rt6_info
*rt
;
3094 struct rt6_nh
*err_nh
;
3095 struct rt6_nh
*nh
, *nh_safe
;
3101 int replace
= (cfg
->fc_nlinfo
.nlh
&&
3102 (cfg
->fc_nlinfo
.nlh
->nlmsg_flags
& NLM_F_REPLACE
));
3103 LIST_HEAD(rt6_nh_list
);
3105 nlflags
= replace
? NLM_F_REPLACE
: NLM_F_CREATE
;
3106 if (info
->nlh
&& info
->nlh
->nlmsg_flags
& NLM_F_APPEND
)
3107 nlflags
|= NLM_F_APPEND
;
3109 remaining
= cfg
->fc_mp_len
;
3110 rtnh
= (struct rtnexthop
*)cfg
->fc_mp
;
3112 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
3113 * rt6_info structs per nexthop
3115 while (rtnh_ok(rtnh
, remaining
)) {
3116 memcpy(&r_cfg
, cfg
, sizeof(*cfg
));
3117 if (rtnh
->rtnh_ifindex
)
3118 r_cfg
.fc_ifindex
= rtnh
->rtnh_ifindex
;
3120 attrlen
= rtnh_attrlen(rtnh
);
3122 struct nlattr
*nla
, *attrs
= rtnh_attrs(rtnh
);
3124 nla
= nla_find(attrs
, attrlen
, RTA_GATEWAY
);
3126 r_cfg
.fc_gateway
= nla_get_in6_addr(nla
);
3127 r_cfg
.fc_flags
|= RTF_GATEWAY
;
3129 r_cfg
.fc_encap
= nla_find(attrs
, attrlen
, RTA_ENCAP
);
3130 nla
= nla_find(attrs
, attrlen
, RTA_ENCAP_TYPE
);
3132 r_cfg
.fc_encap_type
= nla_get_u16(nla
);
3135 rt
= ip6_route_info_create(&r_cfg
, extack
);
3142 err
= ip6_route_info_append(&rt6_nh_list
, rt
, &r_cfg
);
3144 dst_release_immediate(&rt
->dst
);
3148 rtnh
= rtnh_next(rtnh
, &remaining
);
3151 /* for add and replace send one notification with all nexthops.
3152 * Skip the notification in fib6_add_rt2node and send one with
3153 * the full route when done
3155 info
->skip_notify
= 1;
3158 list_for_each_entry(nh
, &rt6_nh_list
, next
) {
3159 rt_last
= nh
->rt6_info
;
3160 err
= __ip6_ins_rt(nh
->rt6_info
, info
, &nh
->mxc
, extack
);
3161 /* save reference to first route for notification */
3162 if (!rt_notif
&& !err
)
3163 rt_notif
= nh
->rt6_info
;
3165 /* nh->rt6_info is used or freed at this point, reset to NULL*/
3166 nh
->rt6_info
= NULL
;
3169 ip6_print_replace_route_err(&rt6_nh_list
);
3174 /* Because each route is added like a single route we remove
3175 * these flags after the first nexthop: if there is a collision,
3176 * we have already failed to add the first nexthop:
3177 * fib6_add_rt2node() has rejected it; when replacing, old
3178 * nexthops have been replaced by first new, the rest should
3181 cfg
->fc_nlinfo
.nlh
->nlmsg_flags
&= ~(NLM_F_EXCL
|
3186 /* success ... tell user about new route */
3187 ip6_route_mpath_notify(rt_notif
, rt_last
, info
, nlflags
);
3191 /* send notification for routes that were added so that
3192 * the delete notifications sent by ip6_route_del are
3196 ip6_route_mpath_notify(rt_notif
, rt_last
, info
, nlflags
);
3198 /* Delete routes that were already added */
3199 list_for_each_entry(nh
, &rt6_nh_list
, next
) {
3202 ip6_route_del(&nh
->r_cfg
, extack
);
3206 list_for_each_entry_safe(nh
, nh_safe
, &rt6_nh_list
, next
) {
3208 dst_release_immediate(&nh
->rt6_info
->dst
);
3210 list_del(&nh
->next
);
3217 static int ip6_route_multipath_del(struct fib6_config
*cfg
,
3218 struct netlink_ext_ack
*extack
)
3220 struct fib6_config r_cfg
;
3221 struct rtnexthop
*rtnh
;
3224 int err
= 1, last_err
= 0;
3226 remaining
= cfg
->fc_mp_len
;
3227 rtnh
= (struct rtnexthop
*)cfg
->fc_mp
;
3229 /* Parse a Multipath Entry */
3230 while (rtnh_ok(rtnh
, remaining
)) {
3231 memcpy(&r_cfg
, cfg
, sizeof(*cfg
));
3232 if (rtnh
->rtnh_ifindex
)
3233 r_cfg
.fc_ifindex
= rtnh
->rtnh_ifindex
;
3235 attrlen
= rtnh_attrlen(rtnh
);
3237 struct nlattr
*nla
, *attrs
= rtnh_attrs(rtnh
);
3239 nla
= nla_find(attrs
, attrlen
, RTA_GATEWAY
);
3241 nla_memcpy(&r_cfg
.fc_gateway
, nla
, 16);
3242 r_cfg
.fc_flags
|= RTF_GATEWAY
;
3245 err
= ip6_route_del(&r_cfg
, extack
);
3249 rtnh
= rtnh_next(rtnh
, &remaining
);
3255 static int inet6_rtm_delroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
3256 struct netlink_ext_ack
*extack
)
3258 struct fib6_config cfg
;
3261 err
= rtm_to_fib6_config(skb
, nlh
, &cfg
, extack
);
3266 return ip6_route_multipath_del(&cfg
, extack
);
3268 cfg
.fc_delete_all_nh
= 1;
3269 return ip6_route_del(&cfg
, extack
);
3273 static int inet6_rtm_newroute(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
3274 struct netlink_ext_ack
*extack
)
3276 struct fib6_config cfg
;
3279 err
= rtm_to_fib6_config(skb
, nlh
, &cfg
, extack
);
3284 return ip6_route_multipath_add(&cfg
, extack
);
3286 return ip6_route_add(&cfg
, extack
);
3289 static size_t rt6_nlmsg_size(struct rt6_info
*rt
)
3291 int nexthop_len
= 0;
3293 if (rt
->rt6i_nsiblings
) {
3294 nexthop_len
= nla_total_size(0) /* RTA_MULTIPATH */
3295 + NLA_ALIGN(sizeof(struct rtnexthop
))
3296 + nla_total_size(16) /* RTA_GATEWAY */
3297 + lwtunnel_get_encap_size(rt
->dst
.lwtstate
);
3299 nexthop_len
*= rt
->rt6i_nsiblings
;
3302 return NLMSG_ALIGN(sizeof(struct rtmsg
))
3303 + nla_total_size(16) /* RTA_SRC */
3304 + nla_total_size(16) /* RTA_DST */
3305 + nla_total_size(16) /* RTA_GATEWAY */
3306 + nla_total_size(16) /* RTA_PREFSRC */
3307 + nla_total_size(4) /* RTA_TABLE */
3308 + nla_total_size(4) /* RTA_IIF */
3309 + nla_total_size(4) /* RTA_OIF */
3310 + nla_total_size(4) /* RTA_PRIORITY */
3311 + RTAX_MAX
* nla_total_size(4) /* RTA_METRICS */
3312 + nla_total_size(sizeof(struct rta_cacheinfo
))
3313 + nla_total_size(TCP_CA_NAME_MAX
) /* RTAX_CC_ALGO */
3314 + nla_total_size(1) /* RTA_PREF */
3315 + lwtunnel_get_encap_size(rt
->dst
.lwtstate
)
3319 static int rt6_nexthop_info(struct sk_buff
*skb
, struct rt6_info
*rt
,
3320 unsigned int *flags
, bool skip_oif
)
3322 if (!netif_running(rt
->dst
.dev
) || !netif_carrier_ok(rt
->dst
.dev
)) {
3323 *flags
|= RTNH_F_LINKDOWN
;
3324 if (rt
->rt6i_idev
->cnf
.ignore_routes_with_linkdown
)
3325 *flags
|= RTNH_F_DEAD
;
3328 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
3329 if (nla_put_in6_addr(skb
, RTA_GATEWAY
, &rt
->rt6i_gateway
) < 0)
3330 goto nla_put_failure
;
3333 /* not needed for multipath encoding b/c it has a rtnexthop struct */
3334 if (!skip_oif
&& rt
->dst
.dev
&&
3335 nla_put_u32(skb
, RTA_OIF
, rt
->dst
.dev
->ifindex
))
3336 goto nla_put_failure
;
3338 if (rt
->dst
.lwtstate
&&
3339 lwtunnel_fill_encap(skb
, rt
->dst
.lwtstate
) < 0)
3340 goto nla_put_failure
;
3348 /* add multipath next hop */
3349 static int rt6_add_nexthop(struct sk_buff
*skb
, struct rt6_info
*rt
)
3351 struct rtnexthop
*rtnh
;
3352 unsigned int flags
= 0;
3354 rtnh
= nla_reserve_nohdr(skb
, sizeof(*rtnh
));
3356 goto nla_put_failure
;
3358 rtnh
->rtnh_hops
= 0;
3359 rtnh
->rtnh_ifindex
= rt
->dst
.dev
? rt
->dst
.dev
->ifindex
: 0;
3361 if (rt6_nexthop_info(skb
, rt
, &flags
, true) < 0)
3362 goto nla_put_failure
;
3364 rtnh
->rtnh_flags
= flags
;
3366 /* length of rtnetlink header + attributes */
3367 rtnh
->rtnh_len
= nlmsg_get_pos(skb
) - (void *)rtnh
;
3375 static int rt6_fill_node(struct net
*net
,
3376 struct sk_buff
*skb
, struct rt6_info
*rt
,
3377 struct in6_addr
*dst
, struct in6_addr
*src
,
3378 int iif
, int type
, u32 portid
, u32 seq
,
3381 u32 metrics
[RTAX_MAX
];
3383 struct nlmsghdr
*nlh
;
3387 nlh
= nlmsg_put(skb
, portid
, seq
, type
, sizeof(*rtm
), flags
);
3391 rtm
= nlmsg_data(nlh
);
3392 rtm
->rtm_family
= AF_INET6
;
3393 rtm
->rtm_dst_len
= rt
->rt6i_dst
.plen
;
3394 rtm
->rtm_src_len
= rt
->rt6i_src
.plen
;
3397 table
= rt
->rt6i_table
->tb6_id
;
3399 table
= RT6_TABLE_UNSPEC
;
3400 rtm
->rtm_table
= table
;
3401 if (nla_put_u32(skb
, RTA_TABLE
, table
))
3402 goto nla_put_failure
;
3403 if (rt
->rt6i_flags
& RTF_REJECT
) {
3404 switch (rt
->dst
.error
) {
3406 rtm
->rtm_type
= RTN_BLACKHOLE
;
3409 rtm
->rtm_type
= RTN_PROHIBIT
;
3412 rtm
->rtm_type
= RTN_THROW
;
3415 rtm
->rtm_type
= RTN_UNREACHABLE
;
3419 else if (rt
->rt6i_flags
& RTF_LOCAL
)
3420 rtm
->rtm_type
= RTN_LOCAL
;
3421 else if (rt
->rt6i_flags
& RTF_ANYCAST
)
3422 rtm
->rtm_type
= RTN_ANYCAST
;
3423 else if (rt
->dst
.dev
&& (rt
->dst
.dev
->flags
& IFF_LOOPBACK
))
3424 rtm
->rtm_type
= RTN_LOCAL
;
3426 rtm
->rtm_type
= RTN_UNICAST
;
3428 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
3429 rtm
->rtm_protocol
= rt
->rt6i_protocol
;
3431 if (rt
->rt6i_flags
& RTF_CACHE
)
3432 rtm
->rtm_flags
|= RTM_F_CLONED
;
3435 if (nla_put_in6_addr(skb
, RTA_DST
, dst
))
3436 goto nla_put_failure
;
3437 rtm
->rtm_dst_len
= 128;
3438 } else if (rtm
->rtm_dst_len
)
3439 if (nla_put_in6_addr(skb
, RTA_DST
, &rt
->rt6i_dst
.addr
))
3440 goto nla_put_failure
;
3441 #ifdef CONFIG_IPV6_SUBTREES
3443 if (nla_put_in6_addr(skb
, RTA_SRC
, src
))
3444 goto nla_put_failure
;
3445 rtm
->rtm_src_len
= 128;
3446 } else if (rtm
->rtm_src_len
&&
3447 nla_put_in6_addr(skb
, RTA_SRC
, &rt
->rt6i_src
.addr
))
3448 goto nla_put_failure
;
3451 #ifdef CONFIG_IPV6_MROUTE
3452 if (ipv6_addr_is_multicast(&rt
->rt6i_dst
.addr
)) {
3453 int err
= ip6mr_get_route(net
, skb
, rtm
, portid
);
3458 goto nla_put_failure
;
3461 if (nla_put_u32(skb
, RTA_IIF
, iif
))
3462 goto nla_put_failure
;
3464 struct in6_addr saddr_buf
;
3465 if (ip6_route_get_saddr(net
, rt
, dst
, 0, &saddr_buf
) == 0 &&
3466 nla_put_in6_addr(skb
, RTA_PREFSRC
, &saddr_buf
))
3467 goto nla_put_failure
;
3470 if (rt
->rt6i_prefsrc
.plen
) {
3471 struct in6_addr saddr_buf
;
3472 saddr_buf
= rt
->rt6i_prefsrc
.addr
;
3473 if (nla_put_in6_addr(skb
, RTA_PREFSRC
, &saddr_buf
))
3474 goto nla_put_failure
;
3477 memcpy(metrics
, dst_metrics_ptr(&rt
->dst
), sizeof(metrics
));
3479 metrics
[RTAX_MTU
- 1] = rt
->rt6i_pmtu
;
3480 if (rtnetlink_put_metrics(skb
, metrics
) < 0)
3481 goto nla_put_failure
;
3483 if (nla_put_u32(skb
, RTA_PRIORITY
, rt
->rt6i_metric
))
3484 goto nla_put_failure
;
3486 /* For multipath routes, walk the siblings list and add
3487 * each as a nexthop within RTA_MULTIPATH.
3489 if (rt
->rt6i_nsiblings
) {
3490 struct rt6_info
*sibling
, *next_sibling
;
3493 mp
= nla_nest_start(skb
, RTA_MULTIPATH
);
3495 goto nla_put_failure
;
3497 if (rt6_add_nexthop(skb
, rt
) < 0)
3498 goto nla_put_failure
;
3500 list_for_each_entry_safe(sibling
, next_sibling
,
3501 &rt
->rt6i_siblings
, rt6i_siblings
) {
3502 if (rt6_add_nexthop(skb
, sibling
) < 0)
3503 goto nla_put_failure
;
3506 nla_nest_end(skb
, mp
);
3508 if (rt6_nexthop_info(skb
, rt
, &rtm
->rtm_flags
, false) < 0)
3509 goto nla_put_failure
;
3512 expires
= (rt
->rt6i_flags
& RTF_EXPIRES
) ? rt
->dst
.expires
- jiffies
: 0;
3514 if (rtnl_put_cacheinfo(skb
, &rt
->dst
, 0, expires
, rt
->dst
.error
) < 0)
3515 goto nla_put_failure
;
3517 if (nla_put_u8(skb
, RTA_PREF
, IPV6_EXTRACT_PREF(rt
->rt6i_flags
)))
3518 goto nla_put_failure
;
3521 nlmsg_end(skb
, nlh
);
3525 nlmsg_cancel(skb
, nlh
);
3529 int rt6_dump_route(struct rt6_info
*rt
, void *p_arg
)
3531 struct rt6_rtnl_dump_arg
*arg
= (struct rt6_rtnl_dump_arg
*) p_arg
;
3532 struct net
*net
= arg
->net
;
3534 if (rt
== net
->ipv6
.ip6_null_entry
)
3537 if (nlmsg_len(arg
->cb
->nlh
) >= sizeof(struct rtmsg
)) {
3538 struct rtmsg
*rtm
= nlmsg_data(arg
->cb
->nlh
);
3540 /* user wants prefix routes only */
3541 if (rtm
->rtm_flags
& RTM_F_PREFIX
&&
3542 !(rt
->rt6i_flags
& RTF_PREFIX_RT
)) {
3543 /* success since this is not a prefix route */
3548 return rt6_fill_node(net
,
3549 arg
->skb
, rt
, NULL
, NULL
, 0, RTM_NEWROUTE
,
3550 NETLINK_CB(arg
->cb
->skb
).portid
, arg
->cb
->nlh
->nlmsg_seq
,
3554 static int inet6_rtm_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
*nlh
,
3555 struct netlink_ext_ack
*extack
)
3557 struct net
*net
= sock_net(in_skb
->sk
);
3558 struct nlattr
*tb
[RTA_MAX
+1];
3559 int err
, iif
= 0, oif
= 0;
3560 struct dst_entry
*dst
;
3561 struct rt6_info
*rt
;
3562 struct sk_buff
*skb
;
3567 err
= nlmsg_parse(nlh
, sizeof(*rtm
), tb
, RTA_MAX
, rtm_ipv6_policy
,
3573 memset(&fl6
, 0, sizeof(fl6
));
3574 rtm
= nlmsg_data(nlh
);
3575 fl6
.flowlabel
= ip6_make_flowinfo(rtm
->rtm_tos
, 0);
3576 fibmatch
= !!(rtm
->rtm_flags
& RTM_F_FIB_MATCH
);
3579 if (nla_len(tb
[RTA_SRC
]) < sizeof(struct in6_addr
))
3582 fl6
.saddr
= *(struct in6_addr
*)nla_data(tb
[RTA_SRC
]);
3586 if (nla_len(tb
[RTA_DST
]) < sizeof(struct in6_addr
))
3589 fl6
.daddr
= *(struct in6_addr
*)nla_data(tb
[RTA_DST
]);
3593 iif
= nla_get_u32(tb
[RTA_IIF
]);
3596 oif
= nla_get_u32(tb
[RTA_OIF
]);
3599 fl6
.flowi6_mark
= nla_get_u32(tb
[RTA_MARK
]);
3602 fl6
.flowi6_uid
= make_kuid(current_user_ns(),
3603 nla_get_u32(tb
[RTA_UID
]));
3605 fl6
.flowi6_uid
= iif
? INVALID_UID
: current_uid();
3608 struct net_device
*dev
;
3611 dev
= __dev_get_by_index(net
, iif
);
3617 fl6
.flowi6_iif
= iif
;
3619 if (!ipv6_addr_any(&fl6
.saddr
))
3620 flags
|= RT6_LOOKUP_F_HAS_SADDR
;
3623 dst
= ip6_route_input_lookup(net
, dev
, &fl6
, flags
);
3625 fl6
.flowi6_oif
= oif
;
3628 dst
= ip6_route_output(net
, NULL
, &fl6
);
3632 dst
= ip6_route_lookup(net
, &fl6
, 0);
3634 rt
= container_of(dst
, struct rt6_info
, dst
);
3635 if (rt
->dst
.error
) {
3636 err
= rt
->dst
.error
;
3641 if (rt
== net
->ipv6
.ip6_null_entry
) {
3642 err
= rt
->dst
.error
;
3647 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
3654 skb_dst_set(skb
, &rt
->dst
);
3656 err
= rt6_fill_node(net
, skb
, rt
, NULL
, NULL
, iif
,
3657 RTM_NEWROUTE
, NETLINK_CB(in_skb
).portid
,
3660 err
= rt6_fill_node(net
, skb
, rt
, &fl6
.daddr
, &fl6
.saddr
, iif
,
3661 RTM_NEWROUTE
, NETLINK_CB(in_skb
).portid
,
3668 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
3673 void inet6_rt_notify(int event
, struct rt6_info
*rt
, struct nl_info
*info
,
3674 unsigned int nlm_flags
)
3676 struct sk_buff
*skb
;
3677 struct net
*net
= info
->nl_net
;
3682 seq
= info
->nlh
? info
->nlh
->nlmsg_seq
: 0;
3684 skb
= nlmsg_new(rt6_nlmsg_size(rt
), gfp_any());
3688 err
= rt6_fill_node(net
, skb
, rt
, NULL
, NULL
, 0,
3689 event
, info
->portid
, seq
, nlm_flags
);
3691 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3692 WARN_ON(err
== -EMSGSIZE
);
3696 rtnl_notify(skb
, net
, info
->portid
, RTNLGRP_IPV6_ROUTE
,
3697 info
->nlh
, gfp_any());
3701 rtnl_set_sk_err(net
, RTNLGRP_IPV6_ROUTE
, err
);
3704 static int ip6_route_dev_notify(struct notifier_block
*this,
3705 unsigned long event
, void *ptr
)
3707 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
3708 struct net
*net
= dev_net(dev
);
3710 if (!(dev
->flags
& IFF_LOOPBACK
))
3713 if (event
== NETDEV_REGISTER
) {
3714 net
->ipv6
.ip6_null_entry
->dst
.dev
= dev
;
3715 net
->ipv6
.ip6_null_entry
->rt6i_idev
= in6_dev_get(dev
);
3716 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3717 net
->ipv6
.ip6_prohibit_entry
->dst
.dev
= dev
;
3718 net
->ipv6
.ip6_prohibit_entry
->rt6i_idev
= in6_dev_get(dev
);
3719 net
->ipv6
.ip6_blk_hole_entry
->dst
.dev
= dev
;
3720 net
->ipv6
.ip6_blk_hole_entry
->rt6i_idev
= in6_dev_get(dev
);
3722 } else if (event
== NETDEV_UNREGISTER
&&
3723 dev
->reg_state
!= NETREG_UNREGISTERED
) {
3724 /* NETDEV_UNREGISTER could be fired for multiple times by
3725 * netdev_wait_allrefs(). Make sure we only call this once.
3727 in6_dev_put(net
->ipv6
.ip6_null_entry
->rt6i_idev
);
3728 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3729 in6_dev_put(net
->ipv6
.ip6_prohibit_entry
->rt6i_idev
);
3730 in6_dev_put(net
->ipv6
.ip6_blk_hole_entry
->rt6i_idev
);
3741 #ifdef CONFIG_PROC_FS
3743 static const struct file_operations ipv6_route_proc_fops
= {
3744 .owner
= THIS_MODULE
,
3745 .open
= ipv6_route_open
,
3747 .llseek
= seq_lseek
,
3748 .release
= seq_release_net
,
3751 static int rt6_stats_seq_show(struct seq_file
*seq
, void *v
)
3753 struct net
*net
= (struct net
*)seq
->private;
3754 seq_printf(seq
, "%04x %04x %04x %04x %04x %04x %04x\n",
3755 net
->ipv6
.rt6_stats
->fib_nodes
,
3756 net
->ipv6
.rt6_stats
->fib_route_nodes
,
3757 net
->ipv6
.rt6_stats
->fib_rt_alloc
,
3758 net
->ipv6
.rt6_stats
->fib_rt_entries
,
3759 net
->ipv6
.rt6_stats
->fib_rt_cache
,
3760 dst_entries_get_slow(&net
->ipv6
.ip6_dst_ops
),
3761 net
->ipv6
.rt6_stats
->fib_discarded_routes
);
3766 static int rt6_stats_seq_open(struct inode
*inode
, struct file
*file
)
3768 return single_open_net(inode
, file
, rt6_stats_seq_show
);
3771 static const struct file_operations rt6_stats_seq_fops
= {
3772 .owner
= THIS_MODULE
,
3773 .open
= rt6_stats_seq_open
,
3775 .llseek
= seq_lseek
,
3776 .release
= single_release_net
,
3778 #endif /* CONFIG_PROC_FS */
3780 #ifdef CONFIG_SYSCTL
3783 int ipv6_sysctl_rtcache_flush(struct ctl_table
*ctl
, int write
,
3784 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
3791 net
= (struct net
*)ctl
->extra1
;
3792 delay
= net
->ipv6
.sysctl
.flush_delay
;
3793 proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
3794 fib6_run_gc(delay
<= 0 ? 0 : (unsigned long)delay
, net
, delay
> 0);
3798 struct ctl_table ipv6_route_table_template
[] = {
3800 .procname
= "flush",
3801 .data
= &init_net
.ipv6
.sysctl
.flush_delay
,
3802 .maxlen
= sizeof(int),
3804 .proc_handler
= ipv6_sysctl_rtcache_flush
3807 .procname
= "gc_thresh",
3808 .data
= &ip6_dst_ops_template
.gc_thresh
,
3809 .maxlen
= sizeof(int),
3811 .proc_handler
= proc_dointvec
,
3814 .procname
= "max_size",
3815 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_max_size
,
3816 .maxlen
= sizeof(int),
3818 .proc_handler
= proc_dointvec
,
3821 .procname
= "gc_min_interval",
3822 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_min_interval
,
3823 .maxlen
= sizeof(int),
3825 .proc_handler
= proc_dointvec_jiffies
,
3828 .procname
= "gc_timeout",
3829 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_timeout
,
3830 .maxlen
= sizeof(int),
3832 .proc_handler
= proc_dointvec_jiffies
,
3835 .procname
= "gc_interval",
3836 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_interval
,
3837 .maxlen
= sizeof(int),
3839 .proc_handler
= proc_dointvec_jiffies
,
3842 .procname
= "gc_elasticity",
3843 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_elasticity
,
3844 .maxlen
= sizeof(int),
3846 .proc_handler
= proc_dointvec
,
3849 .procname
= "mtu_expires",
3850 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_mtu_expires
,
3851 .maxlen
= sizeof(int),
3853 .proc_handler
= proc_dointvec_jiffies
,
3856 .procname
= "min_adv_mss",
3857 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_min_advmss
,
3858 .maxlen
= sizeof(int),
3860 .proc_handler
= proc_dointvec
,
3863 .procname
= "gc_min_interval_ms",
3864 .data
= &init_net
.ipv6
.sysctl
.ip6_rt_gc_min_interval
,
3865 .maxlen
= sizeof(int),
3867 .proc_handler
= proc_dointvec_ms_jiffies
,
3872 struct ctl_table
* __net_init
ipv6_route_sysctl_init(struct net
*net
)
3874 struct ctl_table
*table
;
3876 table
= kmemdup(ipv6_route_table_template
,
3877 sizeof(ipv6_route_table_template
),
3881 table
[0].data
= &net
->ipv6
.sysctl
.flush_delay
;
3882 table
[0].extra1
= net
;
3883 table
[1].data
= &net
->ipv6
.ip6_dst_ops
.gc_thresh
;
3884 table
[2].data
= &net
->ipv6
.sysctl
.ip6_rt_max_size
;
3885 table
[3].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
;
3886 table
[4].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_timeout
;
3887 table
[5].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_interval
;
3888 table
[6].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_elasticity
;
3889 table
[7].data
= &net
->ipv6
.sysctl
.ip6_rt_mtu_expires
;
3890 table
[8].data
= &net
->ipv6
.sysctl
.ip6_rt_min_advmss
;
3891 table
[9].data
= &net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
;
3893 /* Don't export sysctls to unprivileged users */
3894 if (net
->user_ns
!= &init_user_ns
)
3895 table
[0].procname
= NULL
;
3902 static int __net_init
ip6_route_net_init(struct net
*net
)
3906 memcpy(&net
->ipv6
.ip6_dst_ops
, &ip6_dst_ops_template
,
3907 sizeof(net
->ipv6
.ip6_dst_ops
));
3909 if (dst_entries_init(&net
->ipv6
.ip6_dst_ops
) < 0)
3910 goto out_ip6_dst_ops
;
3912 net
->ipv6
.ip6_null_entry
= kmemdup(&ip6_null_entry_template
,
3913 sizeof(*net
->ipv6
.ip6_null_entry
),
3915 if (!net
->ipv6
.ip6_null_entry
)
3916 goto out_ip6_dst_entries
;
3917 net
->ipv6
.ip6_null_entry
->dst
.path
=
3918 (struct dst_entry
*)net
->ipv6
.ip6_null_entry
;
3919 net
->ipv6
.ip6_null_entry
->dst
.ops
= &net
->ipv6
.ip6_dst_ops
;
3920 dst_init_metrics(&net
->ipv6
.ip6_null_entry
->dst
,
3921 ip6_template_metrics
, true);
3923 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3924 net
->ipv6
.ip6_prohibit_entry
= kmemdup(&ip6_prohibit_entry_template
,
3925 sizeof(*net
->ipv6
.ip6_prohibit_entry
),
3927 if (!net
->ipv6
.ip6_prohibit_entry
)
3928 goto out_ip6_null_entry
;
3929 net
->ipv6
.ip6_prohibit_entry
->dst
.path
=
3930 (struct dst_entry
*)net
->ipv6
.ip6_prohibit_entry
;
3931 net
->ipv6
.ip6_prohibit_entry
->dst
.ops
= &net
->ipv6
.ip6_dst_ops
;
3932 dst_init_metrics(&net
->ipv6
.ip6_prohibit_entry
->dst
,
3933 ip6_template_metrics
, true);
3935 net
->ipv6
.ip6_blk_hole_entry
= kmemdup(&ip6_blk_hole_entry_template
,
3936 sizeof(*net
->ipv6
.ip6_blk_hole_entry
),
3938 if (!net
->ipv6
.ip6_blk_hole_entry
)
3939 goto out_ip6_prohibit_entry
;
3940 net
->ipv6
.ip6_blk_hole_entry
->dst
.path
=
3941 (struct dst_entry
*)net
->ipv6
.ip6_blk_hole_entry
;
3942 net
->ipv6
.ip6_blk_hole_entry
->dst
.ops
= &net
->ipv6
.ip6_dst_ops
;
3943 dst_init_metrics(&net
->ipv6
.ip6_blk_hole_entry
->dst
,
3944 ip6_template_metrics
, true);
3947 net
->ipv6
.sysctl
.flush_delay
= 0;
3948 net
->ipv6
.sysctl
.ip6_rt_max_size
= 4096;
3949 net
->ipv6
.sysctl
.ip6_rt_gc_min_interval
= HZ
/ 2;
3950 net
->ipv6
.sysctl
.ip6_rt_gc_timeout
= 60*HZ
;
3951 net
->ipv6
.sysctl
.ip6_rt_gc_interval
= 30*HZ
;
3952 net
->ipv6
.sysctl
.ip6_rt_gc_elasticity
= 9;
3953 net
->ipv6
.sysctl
.ip6_rt_mtu_expires
= 10*60*HZ
;
3954 net
->ipv6
.sysctl
.ip6_rt_min_advmss
= IPV6_MIN_MTU
- 20 - 40;
3956 net
->ipv6
.ip6_rt_gc_expire
= 30*HZ
;
3962 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3963 out_ip6_prohibit_entry
:
3964 kfree(net
->ipv6
.ip6_prohibit_entry
);
3966 kfree(net
->ipv6
.ip6_null_entry
);
3968 out_ip6_dst_entries
:
3969 dst_entries_destroy(&net
->ipv6
.ip6_dst_ops
);
3974 static void __net_exit
ip6_route_net_exit(struct net
*net
)
3976 kfree(net
->ipv6
.ip6_null_entry
);
3977 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3978 kfree(net
->ipv6
.ip6_prohibit_entry
);
3979 kfree(net
->ipv6
.ip6_blk_hole_entry
);
3981 dst_entries_destroy(&net
->ipv6
.ip6_dst_ops
);
3984 static int __net_init
ip6_route_net_init_late(struct net
*net
)
3986 #ifdef CONFIG_PROC_FS
3987 proc_create("ipv6_route", 0, net
->proc_net
, &ipv6_route_proc_fops
);
3988 proc_create("rt6_stats", S_IRUGO
, net
->proc_net
, &rt6_stats_seq_fops
);
3993 static void __net_exit
ip6_route_net_exit_late(struct net
*net
)
3995 #ifdef CONFIG_PROC_FS
3996 remove_proc_entry("ipv6_route", net
->proc_net
);
3997 remove_proc_entry("rt6_stats", net
->proc_net
);
4001 static struct pernet_operations ip6_route_net_ops
= {
4002 .init
= ip6_route_net_init
,
4003 .exit
= ip6_route_net_exit
,
4006 static int __net_init
ipv6_inetpeer_init(struct net
*net
)
4008 struct inet_peer_base
*bp
= kmalloc(sizeof(*bp
), GFP_KERNEL
);
4012 inet_peer_base_init(bp
);
4013 net
->ipv6
.peers
= bp
;
4017 static void __net_exit
ipv6_inetpeer_exit(struct net
*net
)
4019 struct inet_peer_base
*bp
= net
->ipv6
.peers
;
4021 net
->ipv6
.peers
= NULL
;
4022 inetpeer_invalidate_tree(bp
);
4026 static struct pernet_operations ipv6_inetpeer_ops
= {
4027 .init
= ipv6_inetpeer_init
,
4028 .exit
= ipv6_inetpeer_exit
,
4031 static struct pernet_operations ip6_route_net_late_ops
= {
4032 .init
= ip6_route_net_init_late
,
4033 .exit
= ip6_route_net_exit_late
,
4036 static struct notifier_block ip6_route_dev_notifier
= {
4037 .notifier_call
= ip6_route_dev_notify
,
4038 .priority
= ADDRCONF_NOTIFY_PRIORITY
- 10,
4041 void __init
ip6_route_init_special_entries(void)
4043 /* Registering of the loopback is done before this portion of code,
4044 * the loopback reference in rt6_info will not be taken, do it
4045 * manually for init_net */
4046 init_net
.ipv6
.ip6_null_entry
->dst
.dev
= init_net
.loopback_dev
;
4047 init_net
.ipv6
.ip6_null_entry
->rt6i_idev
= in6_dev_get(init_net
.loopback_dev
);
4048 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
4049 init_net
.ipv6
.ip6_prohibit_entry
->dst
.dev
= init_net
.loopback_dev
;
4050 init_net
.ipv6
.ip6_prohibit_entry
->rt6i_idev
= in6_dev_get(init_net
.loopback_dev
);
4051 init_net
.ipv6
.ip6_blk_hole_entry
->dst
.dev
= init_net
.loopback_dev
;
4052 init_net
.ipv6
.ip6_blk_hole_entry
->rt6i_idev
= in6_dev_get(init_net
.loopback_dev
);
4056 int __init
ip6_route_init(void)
4062 ip6_dst_ops_template
.kmem_cachep
=
4063 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info
), 0,
4064 SLAB_HWCACHE_ALIGN
, NULL
);
4065 if (!ip6_dst_ops_template
.kmem_cachep
)
4068 ret
= dst_entries_init(&ip6_dst_blackhole_ops
);
4070 goto out_kmem_cache
;
4072 ret
= register_pernet_subsys(&ipv6_inetpeer_ops
);
4074 goto out_dst_entries
;
4076 ret
= register_pernet_subsys(&ip6_route_net_ops
);
4078 goto out_register_inetpeer
;
4080 ip6_dst_blackhole_ops
.kmem_cachep
= ip6_dst_ops_template
.kmem_cachep
;
4084 goto out_register_subsys
;
4090 ret
= fib6_rules_init();
4094 ret
= register_pernet_subsys(&ip6_route_net_late_ops
);
4096 goto fib6_rules_init
;
4099 if (__rtnl_register(PF_INET6
, RTM_NEWROUTE
, inet6_rtm_newroute
, NULL
, NULL
) ||
4100 __rtnl_register(PF_INET6
, RTM_DELROUTE
, inet6_rtm_delroute
, NULL
, NULL
) ||
4101 __rtnl_register(PF_INET6
, RTM_GETROUTE
, inet6_rtm_getroute
, NULL
, NULL
))
4102 goto out_register_late_subsys
;
4104 ret
= register_netdevice_notifier(&ip6_route_dev_notifier
);
4106 goto out_register_late_subsys
;
4108 for_each_possible_cpu(cpu
) {
4109 struct uncached_list
*ul
= per_cpu_ptr(&rt6_uncached_list
, cpu
);
4111 INIT_LIST_HEAD(&ul
->head
);
4112 spin_lock_init(&ul
->lock
);
4118 out_register_late_subsys
:
4119 unregister_pernet_subsys(&ip6_route_net_late_ops
);
4121 fib6_rules_cleanup();
4126 out_register_subsys
:
4127 unregister_pernet_subsys(&ip6_route_net_ops
);
4128 out_register_inetpeer
:
4129 unregister_pernet_subsys(&ipv6_inetpeer_ops
);
4131 dst_entries_destroy(&ip6_dst_blackhole_ops
);
4133 kmem_cache_destroy(ip6_dst_ops_template
.kmem_cachep
);
4137 void ip6_route_cleanup(void)
4139 unregister_netdevice_notifier(&ip6_route_dev_notifier
);
4140 unregister_pernet_subsys(&ip6_route_net_late_ops
);
4141 fib6_rules_cleanup();
4144 unregister_pernet_subsys(&ipv6_inetpeer_ops
);
4145 unregister_pernet_subsys(&ip6_route_net_ops
);
4146 dst_entries_destroy(&ip6_dst_blackhole_ops
);
4147 kmem_cache_destroy(ip6_dst_ops_template
.kmem_cachep
);