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