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