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