projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[TCP]: Remove dead code in init_sequence
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / ipv6 / route.c
CommitLineData
1da177e4
LT		 1/*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16/* Changes:
17 *
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
c0bece9f
YH		 25 * Ville Nuorvala
26 * Fixed routing subtrees.
1da177e4
LT		 27 */
28
4fc268d2 29#include <linux/capability.h>
1da177e4
LT		 30#include <linux/errno.h>
31#include <linux/types.h>
32#include <linux/times.h>
33#include <linux/socket.h>
34#include <linux/sockios.h>
35#include <linux/net.h>
36#include <linux/route.h>
37#include <linux/netdevice.h>
38#include <linux/in6.h>
39#include <linux/init.h>
1da177e4
LT		 40#include <linux/if_arp.h>
41
42#ifdef CONFIG_PROC_FS
43#include <linux/proc_fs.h>
44#include <linux/seq_file.h>
45#endif
46
47#include <net/snmp.h>
48#include <net/ipv6.h>
49#include <net/ip6_fib.h>
50#include <net/ip6_route.h>
51#include <net/ndisc.h>
52#include <net/addrconf.h>
53#include <net/tcp.h>
54#include <linux/rtnetlink.h>
55#include <net/dst.h>
56#include <net/xfrm.h>
8d71740c 57#include <net/netevent.h>
21713ebc 58#include <net/netlink.h>
1da177e4
LT		 59
60#include <asm/uaccess.h>
61
62#ifdef CONFIG_SYSCTL
63#include <linux/sysctl.h>
64#endif
65
66/* Set to 3 to get tracing. */
67#define RT6_DEBUG 2
68
69#if RT6_DEBUG >= 3
70#define RDBG(x) printk x
71#define RT6_TRACE(x...) printk(KERN_DEBUG x)
72#else
73#define RDBG(x)
74#define RT6_TRACE(x...) do { ; } while (0)
75#endif
76
519fbd87 77#define CLONE_OFFLINK_ROUTE 0
1da177e4
LT		 78
79static int ip6_rt_max_size = 4096;
80static int ip6_rt_gc_min_interval = HZ / 2;
81static int ip6_rt_gc_timeout = 60*HZ;
82int ip6_rt_gc_interval = 30*HZ;
83static int ip6_rt_gc_elasticity = 9;
84static int ip6_rt_mtu_expires = 10*60*HZ;
85static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
86
87static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
88static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
89static struct dst_entry *ip6_negative_advice(struct dst_entry *);
90static void ip6_dst_destroy(struct dst_entry *);
91static void ip6_dst_ifdown(struct dst_entry *,
92 struct net_device *dev, int how);
93static int ip6_dst_gc(void);
94
95static int ip6_pkt_discard(struct sk_buff *skb);
96static int ip6_pkt_discard_out(struct sk_buff *skb);
97static void ip6_link_failure(struct sk_buff *skb);
98static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
99
70ceb4f5
YH		 100#ifdef CONFIG_IPV6_ROUTE_INFO
101static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
102 struct in6_addr *gwaddr, int ifindex,
103 unsigned pref);
104static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
105 struct in6_addr *gwaddr, int ifindex);
106#endif
107
1da177e4
LT		 108static struct dst_ops ip6_dst_ops = {
109 .family = AF_INET6,
110 .protocol = __constant_htons(ETH_P_IPV6),
111 .gc = ip6_dst_gc,
112 .gc_thresh = 1024,
113 .check = ip6_dst_check,
114 .destroy = ip6_dst_destroy,
115 .ifdown = ip6_dst_ifdown,
116 .negative_advice = ip6_negative_advice,
117 .link_failure = ip6_link_failure,
118 .update_pmtu = ip6_rt_update_pmtu,
119 .entry_size = sizeof(struct rt6_info),
120};
121
122struct rt6_info ip6_null_entry = {
123 .u = {
124 .dst = {
125 .__refcnt = ATOMIC_INIT(1),
126 .__use = 1,
127 .dev = &loopback_dev,
128 .obsolete = -1,
129 .error = -ENETUNREACH,
130 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
131 .input = ip6_pkt_discard,
132 .output = ip6_pkt_discard_out,
133 .ops = &ip6_dst_ops,
134 .path = (struct dst_entry*)&ip6_null_entry,
135 }
136 },
137 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
138 .rt6i_metric = ~(u32) 0,
139 .rt6i_ref = ATOMIC_INIT(1),
140};
141
101367c2
TG		 142#ifdef CONFIG_IPV6_MULTIPLE_TABLES
143
6723ab54
DM		 144static int ip6_pkt_prohibit(struct sk_buff *skb);
145static int ip6_pkt_prohibit_out(struct sk_buff *skb);
146static int ip6_pkt_blk_hole(struct sk_buff *skb);
147
101367c2
TG		 148struct rt6_info ip6_prohibit_entry = {
149 .u = {
150 .dst = {
151 .__refcnt = ATOMIC_INIT(1),
152 .__use = 1,
153 .dev = &loopback_dev,
154 .obsolete = -1,
155 .error = -EACCES,
156 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
9ce8ade0
TG		 157 .input = ip6_pkt_prohibit,
158 .output = ip6_pkt_prohibit_out,
101367c2
TG		 159 .ops = &ip6_dst_ops,
160 .path = (struct dst_entry*)&ip6_prohibit_entry,
161 }
162 },
163 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
164 .rt6i_metric = ~(u32) 0,
165 .rt6i_ref = ATOMIC_INIT(1),
166};
167
168struct rt6_info ip6_blk_hole_entry = {
169 .u = {
170 .dst = {
171 .__refcnt = ATOMIC_INIT(1),
172 .__use = 1,
173 .dev = &loopback_dev,
174 .obsolete = -1,
175 .error = -EINVAL,
176 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
9ce8ade0
TG		 177 .input = ip6_pkt_blk_hole,
178 .output = ip6_pkt_blk_hole,
101367c2
TG		 179 .ops = &ip6_dst_ops,
180 .path = (struct dst_entry*)&ip6_blk_hole_entry,
181 }
182 },
183 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
184 .rt6i_metric = ~(u32) 0,
185 .rt6i_ref = ATOMIC_INIT(1),
186};
187
188#endif
189
1da177e4
LT		 190/* allocate dst with ip6_dst_ops */
191static __inline__ struct rt6_info *ip6_dst_alloc(void)
192{
193 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
194}
195
196static void ip6_dst_destroy(struct dst_entry *dst)
197{
198 struct rt6_info *rt = (struct rt6_info *)dst;
199 struct inet6_dev *idev = rt->rt6i_idev;
200
201 if (idev != NULL) {
202 rt->rt6i_idev = NULL;
203 in6_dev_put(idev);
204 }
205}
206
207static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
208 int how)
209{
210 struct rt6_info *rt = (struct rt6_info *)dst;
211 struct inet6_dev *idev = rt->rt6i_idev;
212
213 if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
214 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
215 if (loopback_idev != NULL) {
216 rt->rt6i_idev = loopback_idev;
217 in6_dev_put(idev);
218 }
219 }
220}
221
222static __inline__ int rt6_check_expired(const struct rt6_info *rt)
223{
224 return (rt->rt6i_flags & RTF_EXPIRES &&
225 time_after(jiffies, rt->rt6i_expires));
226}
227
c71099ac
TG		 228static inline int rt6_need_strict(struct in6_addr *daddr)
229{
230 return (ipv6_addr_type(daddr) &
231 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
232}
233
1da177e4 234/*
c71099ac 235 * Route lookup. Any table->tb6_lock is implied.
1da177e4
LT		 236 */
237
238static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
239 int oif,
240 int strict)
241{
242 struct rt6_info *local = NULL;
243 struct rt6_info *sprt;
244
245 if (oif) {
246 for (sprt = rt; sprt; sprt = sprt->u.next) {
247 struct net_device *dev = sprt->rt6i_dev;
248 if (dev->ifindex == oif)
249 return sprt;
250 if (dev->flags & IFF_LOOPBACK) {
251 if (sprt->rt6i_idev == NULL ||
252 sprt->rt6i_idev->dev->ifindex != oif) {
253 if (strict && oif)
254 continue;
255 if (local && (!oif ||
256 local->rt6i_idev->dev->ifindex == oif))
257 continue;
258 }
259 local = sprt;
260 }
261 }
262
263 if (local)
264 return local;
265
266 if (strict)
267 return &ip6_null_entry;
268 }
269 return rt;
270}
271
27097255
YH		 272#ifdef CONFIG_IPV6_ROUTER_PREF
273static void rt6_probe(struct rt6_info *rt)
274{
275 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
276 /*
277 * Okay, this does not seem to be appropriate
278 * for now, however, we need to check if it
279 * is really so; aka Router Reachability Probing.
280 *
281 * Router Reachability Probe MUST be rate-limited
282 * to no more than one per minute.
283 */
284 if (!neigh || (neigh->nud_state & NUD_VALID))
285 return;
286 read_lock_bh(&neigh->lock);
287 if (!(neigh->nud_state & NUD_VALID) &&
52e16356 288 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
27097255
YH		 289 struct in6_addr mcaddr;
290 struct in6_addr *target;
291
292 neigh->updated = jiffies;
293 read_unlock_bh(&neigh->lock);
294
295 target = (struct in6_addr *)&neigh->primary_key;
296 addrconf_addr_solict_mult(target, &mcaddr);
297 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
298 } else
299 read_unlock_bh(&neigh->lock);
300}
301#else
302static inline void rt6_probe(struct rt6_info *rt)
303{
304 return;
305}
306#endif
307
1da177e4 308/*
554cfb7e 309 * Default Router Selection (RFC 2461 6.3.6)
1da177e4 310 */
554cfb7e
YH		 311static int inline rt6_check_dev(struct rt6_info *rt, int oif)
312{
313 struct net_device *dev = rt->rt6i_dev;
314 if (!oif || dev->ifindex == oif)
315 return 2;
316 if ((dev->flags & IFF_LOOPBACK) &&
317 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
318 return 1;
319 return 0;
320}
1da177e4 321
554cfb7e 322static int inline rt6_check_neigh(struct rt6_info *rt)
1da177e4 323{
554cfb7e
YH		 324 struct neighbour *neigh = rt->rt6i_nexthop;
325 int m = 0;
4d0c5911
YH		 326 if (rt->rt6i_flags & RTF_NONEXTHOP ||
327 !(rt->rt6i_flags & RTF_GATEWAY))
328 m = 1;
329 else if (neigh) {
554cfb7e
YH		 330 read_lock_bh(&neigh->lock);
331 if (neigh->nud_state & NUD_VALID)
4d0c5911 332 m = 2;
ea73ee23
YH		 333 else if (!(neigh->nud_state & NUD_FAILED))
334 m = 1;
554cfb7e 335 read_unlock_bh(&neigh->lock);
1da177e4 336 }
554cfb7e 337 return m;
1da177e4
LT		 338}
339
554cfb7e
YH		 340static int rt6_score_route(struct rt6_info *rt, int oif,
341 int strict)
1da177e4 342{
4d0c5911
YH		 343 int m, n;
344
345 m = rt6_check_dev(rt, oif);
77d16f45 346 if (!m && (strict & RT6_LOOKUP_F_IFACE))
554cfb7e 347 return -1;
ebacaaa0
YH		 348#ifdef CONFIG_IPV6_ROUTER_PREF
349 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
350#endif
4d0c5911 351 n = rt6_check_neigh(rt);
557e92ef 352 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
554cfb7e
YH		 353 return -1;
354 return m;
355}
356
357static struct rt6_info *rt6_select(struct rt6_info **head, int oif,
358 int strict)
359{
360 struct rt6_info *match = NULL, *last = NULL;
361 struct rt6_info *rt, *rt0 = *head;
362 u32 metric;
363 int mpri = -1;
1da177e4 364
554cfb7e
YH		 365 RT6_TRACE("%s(head=%p(*head=%p), oif=%d)\n",
366 __FUNCTION__, head, head ? *head : NULL, oif);
1da177e4 367
554cfb7e 368 for (rt = rt0, metric = rt0->rt6i_metric;
c302e6d5 369 rt && rt->rt6i_metric == metric && (!last || rt != rt0);
554cfb7e
YH		 370 rt = rt->u.next) {
371 int m;
1da177e4 372
554cfb7e 373 if (rt6_check_expired(rt))
1da177e4
LT		 374 continue;
375
554cfb7e
YH		 376 last = rt;
377
378 m = rt6_score_route(rt, oif, strict);
379 if (m < 0)
1da177e4 380 continue;
1da177e4 381
554cfb7e 382 if (m > mpri) {
ea659e07
YH		 383 if (strict & RT6_LOOKUP_F_REACHABLE)
384 rt6_probe(match);
554cfb7e 385 match = rt;
1da177e4 386 mpri = m;
ea659e07 387 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
27097255 388 rt6_probe(rt);
1da177e4
LT		 389 }
390 }
391
554cfb7e 392 if (!match &&
77d16f45 393 (strict & RT6_LOOKUP_F_REACHABLE) &&
554cfb7e
YH		 394 last && last != rt0) {
395 /* no entries matched; do round-robin */
34af946a 396 static DEFINE_SPINLOCK(lock);
c302e6d5 397 spin_lock(&lock);
554cfb7e
YH		 398 *head = rt0->u.next;
399 rt0->u.next = last->u.next;
400 last->u.next = rt0;
c302e6d5 401 spin_unlock(&lock);
1da177e4 402 }
1da177e4 403
554cfb7e
YH		 404 RT6_TRACE("%s() => %p, score=%d\n",
405 __FUNCTION__, match, mpri);
1da177e4 406
554cfb7e 407 return (match ? match : &ip6_null_entry);
1da177e4
LT		 408}
409
70ceb4f5
YH		 410#ifdef CONFIG_IPV6_ROUTE_INFO
411int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
412 struct in6_addr *gwaddr)
413{
414 struct route_info *rinfo = (struct route_info *) opt;
415 struct in6_addr prefix_buf, *prefix;
416 unsigned int pref;
417 u32 lifetime;
418 struct rt6_info *rt;
419
420 if (len < sizeof(struct route_info)) {
421 return -EINVAL;
422 }
423
424 /* Sanity check for prefix_len and length */
425 if (rinfo->length > 3) {
426 return -EINVAL;
427 } else if (rinfo->prefix_len > 128) {
428 return -EINVAL;
429 } else if (rinfo->prefix_len > 64) {
430 if (rinfo->length < 2) {
431 return -EINVAL;
432 }
433 } else if (rinfo->prefix_len > 0) {
434 if (rinfo->length < 1) {
435 return -EINVAL;
436 }
437 }
438
439 pref = rinfo->route_pref;
440 if (pref == ICMPV6_ROUTER_PREF_INVALID)
441 pref = ICMPV6_ROUTER_PREF_MEDIUM;
442
443 lifetime = htonl(rinfo->lifetime);
444 if (lifetime == 0xffffffff) {
445 /* infinity */
446 } else if (lifetime > 0x7fffffff/HZ) {
447 /* Avoid arithmetic overflow */
448 lifetime = 0x7fffffff/HZ - 1;
449 }
450
451 if (rinfo->length == 3)
452 prefix = (struct in6_addr *)rinfo->prefix;
453 else {
454 /* this function is safe */
455 ipv6_addr_prefix(&prefix_buf,
456 (struct in6_addr *)rinfo->prefix,
457 rinfo->prefix_len);
458 prefix = &prefix_buf;
459 }
460
461 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
462
463 if (rt && !lifetime) {
e0a1ad73 464 ip6_del_rt(rt);
70ceb4f5
YH		 465 rt = NULL;
466 }
467
468 if (!rt && lifetime)
469 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
470 pref);
471 else if (rt)
472 rt->rt6i_flags = RTF_ROUTEINFO |
473 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
474
475 if (rt) {
476 if (lifetime == 0xffffffff) {
477 rt->rt6i_flags &= ~RTF_EXPIRES;
478 } else {
479 rt->rt6i_expires = jiffies + HZ * lifetime;
480 rt->rt6i_flags |= RTF_EXPIRES;
481 }
482 dst_release(&rt->u.dst);
483 }
484 return 0;
485}
486#endif
487
982f56f3
YH		 488#define BACKTRACK(saddr) \
489do { \
490 if (rt == &ip6_null_entry) { \
491 struct fib6_node *pn; \
e0eda7bb 492 while (1) { \
982f56f3
YH		 493 if (fn->fn_flags & RTN_TL_ROOT) \
494 goto out; \
495 pn = fn->parent; \
496 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
497 fn = fib6_lookup(pn->subtree, NULL, saddr); \
498 else \
499 fn = pn; \
500 if (fn->fn_flags & RTN_RTINFO) \
501 goto restart; \
c71099ac 502 } \
c71099ac 503 } \
982f56f3 504} while(0)
c71099ac
TG		 505
506static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
507 struct flowi *fl, int flags)
1da177e4
LT		 508{
509 struct fib6_node *fn;
510 struct rt6_info *rt;
511
c71099ac
TG		 512 read_lock_bh(&table->tb6_lock);
513 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
514restart:
515 rt = fn->leaf;
77d16f45 516 rt = rt6_device_match(rt, fl->oif, flags);
982f56f3 517 BACKTRACK(&fl->fl6_src);
c71099ac 518out:
33cc4896 519 dst_hold(&rt->u.dst);
c71099ac 520 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 521
522 rt->u.dst.lastuse = jiffies;
c71099ac
TG		 523 rt->u.dst.__use++;
524
525 return rt;
526
527}
528
529struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
530 int oif, int strict)
531{
532 struct flowi fl = {
533 .oif = oif,
534 .nl_u = {
535 .ip6_u = {
536 .daddr = *daddr,
c71099ac
TG		 537 },
538 },
539 };
540 struct dst_entry *dst;
77d16f45 541 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
c71099ac 542
adaa70bb
TG		 543 if (saddr) {
544 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
545 flags |= RT6_LOOKUP_F_HAS_SADDR;
546 }
547
c71099ac
TG		 548 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
549 if (dst->error == 0)
550 return (struct rt6_info *) dst;
551
552 dst_release(dst);
553
1da177e4
LT		 554 return NULL;
555}
556
c71099ac 557/* ip6_ins_rt is called with FREE table->tb6_lock.
1da177e4
LT		 558 It takes new route entry, the addition fails by any reason the
559 route is freed. In any case, if caller does not hold it, it may
560 be destroyed.
561 */
562
86872cb5 563static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 564{
565 int err;
c71099ac 566 struct fib6_table *table;
1da177e4 567
c71099ac
TG		 568 table = rt->rt6i_table;
569 write_lock_bh(&table->tb6_lock);
86872cb5 570 err = fib6_add(&table->tb6_root, rt, info);
c71099ac 571 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 572
573 return err;
574}
575
40e22e8f
TG		 576int ip6_ins_rt(struct rt6_info *rt)
577{
86872cb5 578 return __ip6_ins_rt(rt, NULL);
40e22e8f
TG		 579}
580
95a9a5ba
YH		 581static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
582 struct in6_addr *saddr)
1da177e4 583{
1da177e4
LT		 584 struct rt6_info *rt;
585
586 /*
587 * Clone the route.
588 */
589
590 rt = ip6_rt_copy(ort);
591
592 if (rt) {
58c4fb86
YH		 593 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
594 if (rt->rt6i_dst.plen != 128 &&
595 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
596 rt->rt6i_flags |= RTF_ANYCAST;
1da177e4 597 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
58c4fb86 598 }
1da177e4 599
58c4fb86 600 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
1da177e4
LT		 601 rt->rt6i_dst.plen = 128;
602 rt->rt6i_flags |= RTF_CACHE;
603 rt->u.dst.flags |= DST_HOST;
604
605#ifdef CONFIG_IPV6_SUBTREES
606 if (rt->rt6i_src.plen && saddr) {
607 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
608 rt->rt6i_src.plen = 128;
609 }
610#endif
611
612 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
613
95a9a5ba 614 }
1da177e4 615
95a9a5ba
YH		 616 return rt;
617}
1da177e4 618
299d9939
YH		 619static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
620{
621 struct rt6_info *rt = ip6_rt_copy(ort);
622 if (rt) {
623 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
624 rt->rt6i_dst.plen = 128;
625 rt->rt6i_flags |= RTF_CACHE;
299d9939
YH		 626 rt->u.dst.flags |= DST_HOST;
627 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
628 }
629 return rt;
630}
631
8ce11e6a
AB		 632static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
633 struct flowi *fl, int flags)
1da177e4
LT		 634{
635 struct fib6_node *fn;
519fbd87 636 struct rt6_info *rt, *nrt;
c71099ac 637 int strict = 0;
1da177e4 638 int attempts = 3;
519fbd87 639 int err;
ea659e07 640 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
1da177e4 641
77d16f45 642 strict |= flags & RT6_LOOKUP_F_IFACE;
1da177e4
LT		 643
644relookup:
c71099ac 645 read_lock_bh(&table->tb6_lock);
1da177e4 646
8238dd06 647restart_2:
c71099ac 648 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1da177e4
LT		 649
650restart:
c71099ac 651 rt = rt6_select(&fn->leaf, fl->iif, strict | reachable);
982f56f3 652 BACKTRACK(&fl->fl6_src);
8238dd06
YH		 653 if (rt == &ip6_null_entry ||
654 rt->rt6i_flags & RTF_CACHE)
1ddef044 655 goto out;
1da177e4 656
fb9de91e 657 dst_hold(&rt->u.dst);
c71099ac 658 read_unlock_bh(&table->tb6_lock);
fb9de91e 659
519fbd87 660 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
c71099ac 661 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
519fbd87
YH		 662 else {
663#if CLONE_OFFLINK_ROUTE
c71099ac 664 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
519fbd87
YH		 665#else
666 goto out2;
667#endif
668 }
e40cf353 669
519fbd87
YH		 670 dst_release(&rt->u.dst);
671 rt = nrt ? : &ip6_null_entry;
1da177e4 672
519fbd87
YH		 673 dst_hold(&rt->u.dst);
674 if (nrt) {
40e22e8f 675 err = ip6_ins_rt(nrt);
519fbd87 676 if (!err)
1da177e4 677 goto out2;
1da177e4 678 }
1da177e4 679
519fbd87
YH		 680 if (--attempts <= 0)
681 goto out2;
682
683 /*
c71099ac 684 * Race condition! In the gap, when table->tb6_lock was
519fbd87
YH		 685 * released someone could insert this route. Relookup.
686 */
687 dst_release(&rt->u.dst);
688 goto relookup;
689
690out:
8238dd06
YH		 691 if (reachable) {
692 reachable = 0;
693 goto restart_2;
694 }
519fbd87 695 dst_hold(&rt->u.dst);
c71099ac 696 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 697out2:
698 rt->u.dst.lastuse = jiffies;
699 rt->u.dst.__use++;
c71099ac
TG		 700
701 return rt;
1da177e4
LT		 702}
703
c71099ac
TG		 704void ip6_route_input(struct sk_buff *skb)
705{
706 struct ipv6hdr *iph = skb->nh.ipv6h;
adaa70bb 707 int flags = RT6_LOOKUP_F_HAS_SADDR;
c71099ac
TG		 708 struct flowi fl = {
709 .iif = skb->dev->ifindex,
710 .nl_u = {
711 .ip6_u = {
712 .daddr = iph->daddr,
713 .saddr = iph->saddr,
90bcaf7b 714 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
c71099ac
TG		 715 },
716 },
47dcf0cb 717 .mark = skb->mark,
c71099ac
TG		 718 .proto = iph->nexthdr,
719 };
adaa70bb
TG		 720
721 if (rt6_need_strict(&iph->daddr))
722 flags |= RT6_LOOKUP_F_IFACE;
c71099ac
TG		 723
724 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
725}
726
727static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
728 struct flowi *fl, int flags)
1da177e4
LT		 729{
730 struct fib6_node *fn;
519fbd87 731 struct rt6_info *rt, *nrt;
c71099ac 732 int strict = 0;
1da177e4 733 int attempts = 3;
519fbd87 734 int err;
ea659e07 735 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
1da177e4 736
77d16f45 737 strict |= flags & RT6_LOOKUP_F_IFACE;
1da177e4
LT		 738
739relookup:
c71099ac 740 read_lock_bh(&table->tb6_lock);
1da177e4 741
8238dd06 742restart_2:
c71099ac 743 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1da177e4
LT		 744
745restart:
8238dd06 746 rt = rt6_select(&fn->leaf, fl->oif, strict | reachable);
982f56f3 747 BACKTRACK(&fl->fl6_src);
8238dd06
YH		 748 if (rt == &ip6_null_entry ||
749 rt->rt6i_flags & RTF_CACHE)
1da177e4 750 goto out;
1da177e4 751
fb9de91e 752 dst_hold(&rt->u.dst);
c71099ac 753 read_unlock_bh(&table->tb6_lock);
fb9de91e 754
519fbd87 755 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
e40cf353 756 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
519fbd87
YH		 757 else {
758#if CLONE_OFFLINK_ROUTE
759 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
760#else
761 goto out2;
762#endif
763 }
1da177e4 764
519fbd87
YH		 765 dst_release(&rt->u.dst);
766 rt = nrt ? : &ip6_null_entry;
1da177e4 767
519fbd87
YH		 768 dst_hold(&rt->u.dst);
769 if (nrt) {
40e22e8f 770 err = ip6_ins_rt(nrt);
519fbd87 771 if (!err)
1da177e4 772 goto out2;
1da177e4 773 }
e40cf353 774
519fbd87
YH		 775 if (--attempts <= 0)
776 goto out2;
777
778 /*
c71099ac 779 * Race condition! In the gap, when table->tb6_lock was
519fbd87
YH		 780 * released someone could insert this route. Relookup.
781 */
782 dst_release(&rt->u.dst);
783 goto relookup;
784
785out:
8238dd06
YH		 786 if (reachable) {
787 reachable = 0;
788 goto restart_2;
789 }
519fbd87 790 dst_hold(&rt->u.dst);
c71099ac 791 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 792out2:
793 rt->u.dst.lastuse = jiffies;
794 rt->u.dst.__use++;
c71099ac
TG		 795 return rt;
796}
797
798struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
799{
800 int flags = 0;
801
802 if (rt6_need_strict(&fl->fl6_dst))
77d16f45 803 flags |= RT6_LOOKUP_F_IFACE;
c71099ac 804
adaa70bb
TG		 805 if (!ipv6_addr_any(&fl->fl6_src))
806 flags |= RT6_LOOKUP_F_HAS_SADDR;
807
c71099ac 808 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
1da177e4
LT		 809}
810
811
812/*
813 * Destination cache support functions
814 */
815
816static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
817{
818 struct rt6_info *rt;
819
820 rt = (struct rt6_info *) dst;
821
822 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
823 return dst;
824
825 return NULL;
826}
827
828static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
829{
830 struct rt6_info *rt = (struct rt6_info *) dst;
831
832 if (rt) {
833 if (rt->rt6i_flags & RTF_CACHE)
e0a1ad73 834 ip6_del_rt(rt);
1da177e4
LT		 835 else
836 dst_release(dst);
837 }
838 return NULL;
839}
840
841static void ip6_link_failure(struct sk_buff *skb)
842{
843 struct rt6_info *rt;
844
845 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
846
847 rt = (struct rt6_info *) skb->dst;
848 if (rt) {
849 if (rt->rt6i_flags&RTF_CACHE) {
850 dst_set_expires(&rt->u.dst, 0);
851 rt->rt6i_flags |= RTF_EXPIRES;
852 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
853 rt->rt6i_node->fn_sernum = -1;
854 }
855}
856
857static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
858{
859 struct rt6_info *rt6 = (struct rt6_info*)dst;
860
861 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
862 rt6->rt6i_flags |= RTF_MODIFIED;
863 if (mtu < IPV6_MIN_MTU) {
864 mtu = IPV6_MIN_MTU;
865 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
866 }
867 dst->metrics[RTAX_MTU-1] = mtu;
8d71740c 868 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
1da177e4
LT		 869 }
870}
871
1da177e4
LT		 872static int ipv6_get_mtu(struct net_device *dev);
873
874static inline unsigned int ipv6_advmss(unsigned int mtu)
875{
876 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
877
878 if (mtu < ip6_rt_min_advmss)
879 mtu = ip6_rt_min_advmss;
880
881 /*
882 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
883 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
884 * IPV6_MAXPLEN is also valid and means: "any MSS,
885 * rely only on pmtu discovery"
886 */
887 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
888 mtu = IPV6_MAXPLEN;
889 return mtu;
890}
891
5d0bbeeb 892static struct dst_entry *ndisc_dst_gc_list;
8ce11e6a 893static DEFINE_SPINLOCK(ndisc_lock);
5d0bbeeb 894
1da177e4
LT		 895struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
896 struct neighbour *neigh,
897 struct in6_addr *addr,
898 int (*output)(struct sk_buff *))
899{
900 struct rt6_info *rt;
901 struct inet6_dev *idev = in6_dev_get(dev);
902
903 if (unlikely(idev == NULL))
904 return NULL;
905
906 rt = ip6_dst_alloc();
907 if (unlikely(rt == NULL)) {
908 in6_dev_put(idev);
909 goto out;
910 }
911
912 dev_hold(dev);
913 if (neigh)
914 neigh_hold(neigh);
915 else
916 neigh = ndisc_get_neigh(dev, addr);
917
918 rt->rt6i_dev = dev;
919 rt->rt6i_idev = idev;
920 rt->rt6i_nexthop = neigh;
921 atomic_set(&rt->u.dst.__refcnt, 1);
922 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
923 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
924 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
925 rt->u.dst.output = output;
926
927#if 0 /* there's no chance to use these for ndisc */
928 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
929 ? DST_HOST
930 : 0;
931 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
932 rt->rt6i_dst.plen = 128;
933#endif
934
5d0bbeeb 935 spin_lock_bh(&ndisc_lock);
1da177e4
LT		 936 rt->u.dst.next = ndisc_dst_gc_list;
937 ndisc_dst_gc_list = &rt->u.dst;
5d0bbeeb 938 spin_unlock_bh(&ndisc_lock);
1da177e4
LT		 939
940 fib6_force_start_gc();
941
942out:
40aa7b90 943 return &rt->u.dst;
1da177e4
LT		 944}
945
946int ndisc_dst_gc(int *more)
947{
948 struct dst_entry *dst, *next, **pprev;
949 int freed;
950
951 next = NULL;
5d0bbeeb
TG		 952 freed = 0;
953
954 spin_lock_bh(&ndisc_lock);
1da177e4 955 pprev = &ndisc_dst_gc_list;
5d0bbeeb 956
1da177e4
LT		 957 while ((dst = *pprev) != NULL) {
958 if (!atomic_read(&dst->__refcnt)) {
959 *pprev = dst->next;
960 dst_free(dst);
961 freed++;
962 } else {
963 pprev = &dst->next;
964 (*more)++;
965 }
966 }
967
5d0bbeeb
TG		 968 spin_unlock_bh(&ndisc_lock);
969
1da177e4
LT		 970 return freed;
971}
972
973static int ip6_dst_gc(void)
974{
975 static unsigned expire = 30*HZ;
976 static unsigned long last_gc;
977 unsigned long now = jiffies;
978
979 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
980 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
981 goto out;
982
983 expire++;
984 fib6_run_gc(expire);
985 last_gc = now;
986 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
987 expire = ip6_rt_gc_timeout>>1;
988
989out:
990 expire -= expire>>ip6_rt_gc_elasticity;
991 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
992}
993
994/* Clean host part of a prefix. Not necessary in radix tree,
995 but results in cleaner routing tables.
996
997 Remove it only when all the things will work!
998 */
999
1000static int ipv6_get_mtu(struct net_device *dev)
1001{
1002 int mtu = IPV6_MIN_MTU;
1003 struct inet6_dev *idev;
1004
1005 idev = in6_dev_get(dev);
1006 if (idev) {
1007 mtu = idev->cnf.mtu6;
1008 in6_dev_put(idev);
1009 }
1010 return mtu;
1011}
1012
1013int ipv6_get_hoplimit(struct net_device *dev)
1014{
1015 int hoplimit = ipv6_devconf.hop_limit;
1016 struct inet6_dev *idev;
1017
1018 idev = in6_dev_get(dev);
1019 if (idev) {
1020 hoplimit = idev->cnf.hop_limit;
1021 in6_dev_put(idev);
1022 }
1023 return hoplimit;
1024}
1025
1026/*
1027 *
1028 */
1029
86872cb5 1030int ip6_route_add(struct fib6_config *cfg)
1da177e4
LT		 1031{
1032 int err;
1da177e4
LT		 1033 struct rt6_info *rt = NULL;
1034 struct net_device *dev = NULL;
1035 struct inet6_dev *idev = NULL;
c71099ac 1036 struct fib6_table *table;
1da177e4
LT		 1037 int addr_type;
1038
86872cb5 1039 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1da177e4
LT		 1040 return -EINVAL;
1041#ifndef CONFIG_IPV6_SUBTREES
86872cb5 1042 if (cfg->fc_src_len)
1da177e4
LT		 1043 return -EINVAL;
1044#endif
86872cb5 1045 if (cfg->fc_ifindex) {
1da177e4 1046 err = -ENODEV;
86872cb5 1047 dev = dev_get_by_index(cfg->fc_ifindex);
1da177e4
LT		 1048 if (!dev)
1049 goto out;
1050 idev = in6_dev_get(dev);
1051 if (!idev)
1052 goto out;
1053 }
1054
86872cb5
TG		 1055 if (cfg->fc_metric == 0)
1056 cfg->fc_metric = IP6_RT_PRIO_USER;
1da177e4 1057
86872cb5 1058 table = fib6_new_table(cfg->fc_table);
c71099ac
TG		 1059 if (table == NULL) {
1060 err = -ENOBUFS;
1061 goto out;
1062 }
1063
1da177e4
LT		 1064 rt = ip6_dst_alloc();
1065
1066 if (rt == NULL) {
1067 err = -ENOMEM;
1068 goto out;
1069 }
1070
1071 rt->u.dst.obsolete = -1;
86872cb5 1072 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
1da177e4 1073
86872cb5
TG		 1074 if (cfg->fc_protocol == RTPROT_UNSPEC)
1075 cfg->fc_protocol = RTPROT_BOOT;
1076 rt->rt6i_protocol = cfg->fc_protocol;
1077
1078 addr_type = ipv6_addr_type(&cfg->fc_dst);
1da177e4
LT		 1079
1080 if (addr_type & IPV6_ADDR_MULTICAST)
1081 rt->u.dst.input = ip6_mc_input;
1082 else
1083 rt->u.dst.input = ip6_forward;
1084
1085 rt->u.dst.output = ip6_output;
1086
86872cb5
TG		 1087 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1088 rt->rt6i_dst.plen = cfg->fc_dst_len;
1da177e4
LT		 1089 if (rt->rt6i_dst.plen == 128)
1090 rt->u.dst.flags = DST_HOST;
1091
1092#ifdef CONFIG_IPV6_SUBTREES
86872cb5
TG		 1093 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1094 rt->rt6i_src.plen = cfg->fc_src_len;
1da177e4
LT		 1095#endif
1096
86872cb5 1097 rt->rt6i_metric = cfg->fc_metric;
1da177e4
LT		 1098
1099 /* We cannot add true routes via loopback here,
1100 they would result in kernel looping; promote them to reject routes
1101 */
86872cb5 1102 if ((cfg->fc_flags & RTF_REJECT) ||
1da177e4
LT		 1103 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1104 /* hold loopback dev/idev if we haven't done so. */
1105 if (dev != &loopback_dev) {
1106 if (dev) {
1107 dev_put(dev);
1108 in6_dev_put(idev);
1109 }
1110 dev = &loopback_dev;
1111 dev_hold(dev);
1112 idev = in6_dev_get(dev);
1113 if (!idev) {
1114 err = -ENODEV;
1115 goto out;
1116 }
1117 }
1118 rt->u.dst.output = ip6_pkt_discard_out;
1119 rt->u.dst.input = ip6_pkt_discard;
1120 rt->u.dst.error = -ENETUNREACH;
1121 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1122 goto install_route;
1123 }
1124
86872cb5 1125 if (cfg->fc_flags & RTF_GATEWAY) {
1da177e4
LT		 1126 struct in6_addr *gw_addr;
1127 int gwa_type;
1128
86872cb5
TG		 1129 gw_addr = &cfg->fc_gateway;
1130 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1da177e4
LT		 1131 gwa_type = ipv6_addr_type(gw_addr);
1132
1133 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1134 struct rt6_info *grt;
1135
1136 /* IPv6 strictly inhibits using not link-local
1137 addresses as nexthop address.
1138 Otherwise, router will not able to send redirects.
1139 It is very good, but in some (rare!) circumstances
1140 (SIT, PtP, NBMA NOARP links) it is handy to allow
1141 some exceptions. --ANK
1142 */
1143 err = -EINVAL;
1144 if (!(gwa_type&IPV6_ADDR_UNICAST))
1145 goto out;
1146
86872cb5 1147 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
1da177e4
LT		 1148
1149 err = -EHOSTUNREACH;
1150 if (grt == NULL)
1151 goto out;
1152 if (dev) {
1153 if (dev != grt->rt6i_dev) {
1154 dst_release(&grt->u.dst);
1155 goto out;
1156 }
1157 } else {
1158 dev = grt->rt6i_dev;
1159 idev = grt->rt6i_idev;
1160 dev_hold(dev);
1161 in6_dev_hold(grt->rt6i_idev);
1162 }
1163 if (!(grt->rt6i_flags&RTF_GATEWAY))
1164 err = 0;
1165 dst_release(&grt->u.dst);
1166
1167 if (err)
1168 goto out;
1169 }
1170 err = -EINVAL;
1171 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1172 goto out;
1173 }
1174
1175 err = -ENODEV;
1176 if (dev == NULL)
1177 goto out;
1178
86872cb5 1179 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1da177e4
LT		 1180 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1181 if (IS_ERR(rt->rt6i_nexthop)) {
1182 err = PTR_ERR(rt->rt6i_nexthop);
1183 rt->rt6i_nexthop = NULL;
1184 goto out;
1185 }
1186 }
1187
86872cb5 1188 rt->rt6i_flags = cfg->fc_flags;
1da177e4
LT		 1189
1190install_route:
86872cb5
TG		 1191 if (cfg->fc_mx) {
1192 struct nlattr *nla;
1193 int remaining;
1194
1195 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1196 int type = nla->nla_type;
1197
1198 if (type) {
1199 if (type > RTAX_MAX) {
1da177e4
LT		 1200 err = -EINVAL;
1201 goto out;
1202 }
86872cb5
TG		 1203
1204 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1da177e4 1205 }
1da177e4
LT		 1206 }
1207 }
1208
1209 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1210 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1211 if (!rt->u.dst.metrics[RTAX_MTU-1])
1212 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1213 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1214 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1215 rt->u.dst.dev = dev;
1216 rt->rt6i_idev = idev;
c71099ac 1217 rt->rt6i_table = table;
86872cb5 1218 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1219
1220out:
1221 if (dev)
1222 dev_put(dev);
1223 if (idev)
1224 in6_dev_put(idev);
1225 if (rt)
40aa7b90 1226 dst_free(&rt->u.dst);
1da177e4
LT		 1227 return err;
1228}
1229
86872cb5 1230static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 1231{
1232 int err;
c71099ac 1233 struct fib6_table *table;
1da177e4 1234
6c813a72
PM		 1235 if (rt == &ip6_null_entry)
1236 return -ENOENT;
1237
c71099ac
TG		 1238 table = rt->rt6i_table;
1239 write_lock_bh(&table->tb6_lock);
1da177e4 1240
86872cb5 1241 err = fib6_del(rt, info);
1da177e4
LT		 1242 dst_release(&rt->u.dst);
1243
c71099ac 1244 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1245
1246 return err;
1247}
1248
e0a1ad73
TG		 1249int ip6_del_rt(struct rt6_info *rt)
1250{
86872cb5 1251 return __ip6_del_rt(rt, NULL);
e0a1ad73
TG		 1252}
1253
86872cb5 1254static int ip6_route_del(struct fib6_config *cfg)
1da177e4 1255{
c71099ac 1256 struct fib6_table *table;
1da177e4
LT		 1257 struct fib6_node *fn;
1258 struct rt6_info *rt;
1259 int err = -ESRCH;
1260
86872cb5 1261 table = fib6_get_table(cfg->fc_table);
c71099ac
TG		 1262 if (table == NULL)
1263 return err;
1264
1265 read_lock_bh(&table->tb6_lock);
1da177e4 1266
c71099ac 1267 fn = fib6_locate(&table->tb6_root,
86872cb5
TG		 1268 &cfg->fc_dst, cfg->fc_dst_len,
1269 &cfg->fc_src, cfg->fc_src_len);
1da177e4
LT		 1270
1271 if (fn) {
1272 for (rt = fn->leaf; rt; rt = rt->u.next) {
86872cb5 1273 if (cfg->fc_ifindex &&
1da177e4 1274 (rt->rt6i_dev == NULL ||
86872cb5 1275 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1da177e4 1276 continue;
86872cb5
TG		 1277 if (cfg->fc_flags & RTF_GATEWAY &&
1278 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 1279 continue;
86872cb5 1280 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4
LT		 1281 continue;
1282 dst_hold(&rt->u.dst);
c71099ac 1283 read_unlock_bh(&table->tb6_lock);
1da177e4 1284
86872cb5 1285 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1286 }
1287 }
c71099ac 1288 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1289
1290 return err;
1291}
1292
1293/*
1294 * Handle redirects
1295 */
a6279458
YH		 1296struct ip6rd_flowi {
1297 struct flowi fl;
1298 struct in6_addr gateway;
1299};
1300
1301static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1302 struct flowi *fl,
1303 int flags)
1da177e4 1304{
a6279458
YH		 1305 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1306 struct rt6_info *rt;
e843b9e1 1307 struct fib6_node *fn;
c71099ac 1308
1da177e4 1309 /*
e843b9e1
YH		 1310 * Get the "current" route for this destination and
1311 * check if the redirect has come from approriate router.
1312 *
1313 * RFC 2461 specifies that redirects should only be
1314 * accepted if they come from the nexthop to the target.
1315 * Due to the way the routes are chosen, this notion
1316 * is a bit fuzzy and one might need to check all possible
1317 * routes.
1da177e4 1318 */
1da177e4 1319
c71099ac 1320 read_lock_bh(&table->tb6_lock);
a6279458 1321 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
e843b9e1
YH		 1322restart:
1323 for (rt = fn->leaf; rt; rt = rt->u.next) {
1324 /*
1325 * Current route is on-link; redirect is always invalid.
1326 *
1327 * Seems, previous statement is not true. It could
1328 * be node, which looks for us as on-link (f.e. proxy ndisc)
1329 * But then router serving it might decide, that we should
1330 * know truth 8)8) --ANK (980726).
1331 */
1332 if (rt6_check_expired(rt))
1333 continue;
1334 if (!(rt->rt6i_flags & RTF_GATEWAY))
1335 continue;
a6279458 1336 if (fl->oif != rt->rt6i_dev->ifindex)
e843b9e1 1337 continue;
a6279458 1338 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
e843b9e1
YH		 1339 continue;
1340 break;
1341 }
a6279458 1342
cb15d9c2 1343 if (!rt)
a6279458 1344 rt = &ip6_null_entry;
cb15d9c2
YH		 1345 BACKTRACK(&fl->fl6_src);
1346out:
a6279458
YH		 1347 dst_hold(&rt->u.dst);
1348
c71099ac 1349 read_unlock_bh(&table->tb6_lock);
e843b9e1 1350
a6279458
YH		 1351 return rt;
1352};
1353
1354static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1355 struct in6_addr *src,
1356 struct in6_addr *gateway,
1357 struct net_device *dev)
1358{
adaa70bb 1359 int flags = RT6_LOOKUP_F_HAS_SADDR;
a6279458
YH		 1360 struct ip6rd_flowi rdfl = {
1361 .fl = {
1362 .oif = dev->ifindex,
1363 .nl_u = {
1364 .ip6_u = {
1365 .daddr = *dest,
1366 .saddr = *src,
1367 },
1368 },
1369 },
1370 .gateway = *gateway,
1371 };
adaa70bb
TG		 1372
1373 if (rt6_need_strict(dest))
1374 flags |= RT6_LOOKUP_F_IFACE;
a6279458
YH		 1375
1376 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1377}
1378
1379void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1380 struct in6_addr *saddr,
1381 struct neighbour *neigh, u8 *lladdr, int on_link)
1382{
1383 struct rt6_info *rt, *nrt = NULL;
1384 struct netevent_redirect netevent;
1385
1386 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1387
1388 if (rt == &ip6_null_entry) {
1da177e4
LT		 1389 if (net_ratelimit())
1390 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1391 "for redirect target\n");
a6279458 1392 goto out;
1da177e4
LT		 1393 }
1394
1da177e4
LT		 1395 /*
1396 * We have finally decided to accept it.
1397 */
1398
1399 neigh_update(neigh, lladdr, NUD_STALE,
1400 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1401 NEIGH_UPDATE_F_OVERRIDE|
1402 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1403 NEIGH_UPDATE_F_ISROUTER))
1404 );
1405
1406 /*
1407 * Redirect received -> path was valid.
1408 * Look, redirects are sent only in response to data packets,
1409 * so that this nexthop apparently is reachable. --ANK
1410 */
1411 dst_confirm(&rt->u.dst);
1412
1413 /* Duplicate redirect: silently ignore. */
1414 if (neigh == rt->u.dst.neighbour)
1415 goto out;
1416
1417 nrt = ip6_rt_copy(rt);
1418 if (nrt == NULL)
1419 goto out;
1420
1421 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1422 if (on_link)
1423 nrt->rt6i_flags &= ~RTF_GATEWAY;
1424
1425 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1426 nrt->rt6i_dst.plen = 128;
1427 nrt->u.dst.flags |= DST_HOST;
1428
1429 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1430 nrt->rt6i_nexthop = neigh_clone(neigh);
1431 /* Reset pmtu, it may be better */
1432 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1433 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1434
40e22e8f 1435 if (ip6_ins_rt(nrt))
1da177e4
LT		 1436 goto out;
1437
8d71740c
TT		 1438 netevent.old = &rt->u.dst;
1439 netevent.new = &nrt->u.dst;
1440 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1441
1da177e4 1442 if (rt->rt6i_flags&RTF_CACHE) {
e0a1ad73 1443 ip6_del_rt(rt);
1da177e4
LT		 1444 return;
1445 }
1446
1447out:
1448 dst_release(&rt->u.dst);
1449 return;
1450}
1451
1452/*
1453 * Handle ICMP "packet too big" messages
1454 * i.e. Path MTU discovery
1455 */
1456
1457void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1458 struct net_device *dev, u32 pmtu)
1459{
1460 struct rt6_info *rt, *nrt;
1461 int allfrag = 0;
1462
1463 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1464 if (rt == NULL)
1465 return;
1466
1467 if (pmtu >= dst_mtu(&rt->u.dst))
1468 goto out;
1469
1470 if (pmtu < IPV6_MIN_MTU) {
1471 /*
1472 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1473 * MTU (1280) and a fragment header should always be included
1474 * after a node receiving Too Big message reporting PMTU is
1475 * less than the IPv6 Minimum Link MTU.
1476 */
1477 pmtu = IPV6_MIN_MTU;
1478 allfrag = 1;
1479 }
1480
1481 /* New mtu received -> path was valid.
1482 They are sent only in response to data packets,
1483 so that this nexthop apparently is reachable. --ANK
1484 */
1485 dst_confirm(&rt->u.dst);
1486
1487 /* Host route. If it is static, it would be better
1488 not to override it, but add new one, so that
1489 when cache entry will expire old pmtu
1490 would return automatically.
1491 */
1492 if (rt->rt6i_flags & RTF_CACHE) {
1493 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1494 if (allfrag)
1495 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1496 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1497 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1498 goto out;
1499 }
1500
1501 /* Network route.
1502 Two cases are possible:
1503 1. It is connected route. Action: COW
1504 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1505 */
d5315b50 1506 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
a1e78363 1507 nrt = rt6_alloc_cow(rt, daddr, saddr);
d5315b50
YH		 1508 else
1509 nrt = rt6_alloc_clone(rt, daddr);
a1e78363 1510
d5315b50 1511 if (nrt) {
a1e78363
YH		 1512 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1513 if (allfrag)
1514 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1515
1516 /* According to RFC 1981, detecting PMTU increase shouldn't be
1517 * happened within 5 mins, the recommended timer is 10 mins.
1518 * Here this route expiration time is set to ip6_rt_mtu_expires
1519 * which is 10 mins. After 10 mins the decreased pmtu is expired
1520 * and detecting PMTU increase will be automatically happened.
1521 */
1522 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1523 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1524
40e22e8f 1525 ip6_ins_rt(nrt);
1da177e4 1526 }
1da177e4
LT		 1527out:
1528 dst_release(&rt->u.dst);
1529}
1530
1531/*
1532 * Misc support functions
1533 */
1534
1535static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1536{
1537 struct rt6_info *rt = ip6_dst_alloc();
1538
1539 if (rt) {
1540 rt->u.dst.input = ort->u.dst.input;
1541 rt->u.dst.output = ort->u.dst.output;
1542
1543 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
22e1e4d8 1544 rt->u.dst.error = ort->u.dst.error;
1da177e4
LT		 1545 rt->u.dst.dev = ort->u.dst.dev;
1546 if (rt->u.dst.dev)
1547 dev_hold(rt->u.dst.dev);
1548 rt->rt6i_idev = ort->rt6i_idev;
1549 if (rt->rt6i_idev)
1550 in6_dev_hold(rt->rt6i_idev);
1551 rt->u.dst.lastuse = jiffies;
1552 rt->rt6i_expires = 0;
1553
1554 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1555 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1556 rt->rt6i_metric = 0;
1557
1558 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1559#ifdef CONFIG_IPV6_SUBTREES
1560 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1561#endif
c71099ac 1562 rt->rt6i_table = ort->rt6i_table;
1da177e4
LT		 1563 }
1564 return rt;
1565}
1566
70ceb4f5
YH		 1567#ifdef CONFIG_IPV6_ROUTE_INFO
1568static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1569 struct in6_addr *gwaddr, int ifindex)
1570{
1571 struct fib6_node *fn;
1572 struct rt6_info *rt = NULL;
c71099ac
TG		 1573 struct fib6_table *table;
1574
1575 table = fib6_get_table(RT6_TABLE_INFO);
1576 if (table == NULL)
1577 return NULL;
70ceb4f5 1578
c71099ac
TG		 1579 write_lock_bh(&table->tb6_lock);
1580 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
70ceb4f5
YH		 1581 if (!fn)
1582 goto out;
1583
1584 for (rt = fn->leaf; rt; rt = rt->u.next) {
1585 if (rt->rt6i_dev->ifindex != ifindex)
1586 continue;
1587 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1588 continue;
1589 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1590 continue;
1591 dst_hold(&rt->u.dst);
1592 break;
1593 }
1594out:
c71099ac 1595 write_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 1596 return rt;
1597}
1598
1599static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1600 struct in6_addr *gwaddr, int ifindex,
1601 unsigned pref)
1602{
86872cb5
TG		 1603 struct fib6_config cfg = {
1604 .fc_table = RT6_TABLE_INFO,
1605 .fc_metric = 1024,
1606 .fc_ifindex = ifindex,
1607 .fc_dst_len = prefixlen,
1608 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1609 RTF_UP | RTF_PREF(pref),
1610 };
1611
1612 ipv6_addr_copy(&cfg.fc_dst, prefix);
1613 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
70ceb4f5 1614
e317da96
YH		 1615 /* We should treat it as a default route if prefix length is 0. */
1616 if (!prefixlen)
86872cb5 1617 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 1618
86872cb5 1619 ip6_route_add(&cfg);
70ceb4f5
YH		 1620
1621 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1622}
1623#endif
1624
1da177e4
LT		 1625struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1626{
1627 struct rt6_info *rt;
c71099ac 1628 struct fib6_table *table;
1da177e4 1629
c71099ac
TG		 1630 table = fib6_get_table(RT6_TABLE_DFLT);
1631 if (table == NULL)
1632 return NULL;
1da177e4 1633
c71099ac
TG		 1634 write_lock_bh(&table->tb6_lock);
1635 for (rt = table->tb6_root.leaf; rt; rt=rt->u.next) {
1da177e4 1636 if (dev == rt->rt6i_dev &&
045927ff 1637 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 1638 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1639 break;
1640 }
1641 if (rt)
1642 dst_hold(&rt->u.dst);
c71099ac 1643 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1644 return rt;
1645}
1646
1647struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
ebacaaa0
YH		 1648 struct net_device *dev,
1649 unsigned int pref)
1da177e4 1650{
86872cb5
TG		 1651 struct fib6_config cfg = {
1652 .fc_table = RT6_TABLE_DFLT,
1653 .fc_metric = 1024,
1654 .fc_ifindex = dev->ifindex,
1655 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1656 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1657 };
1da177e4 1658
86872cb5 1659 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1da177e4 1660
86872cb5 1661 ip6_route_add(&cfg);
1da177e4 1662
1da177e4
LT		 1663 return rt6_get_dflt_router(gwaddr, dev);
1664}
1665
1666void rt6_purge_dflt_routers(void)
1667{
1668 struct rt6_info *rt;
c71099ac
TG		 1669 struct fib6_table *table;
1670
1671 /* NOTE: Keep consistent with rt6_get_dflt_router */
1672 table = fib6_get_table(RT6_TABLE_DFLT);
1673 if (table == NULL)
1674 return;
1da177e4
LT		 1675
1676restart:
c71099ac
TG		 1677 read_lock_bh(&table->tb6_lock);
1678 for (rt = table->tb6_root.leaf; rt; rt = rt->u.next) {
1da177e4
LT		 1679 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1680 dst_hold(&rt->u.dst);
c71099ac 1681 read_unlock_bh(&table->tb6_lock);
e0a1ad73 1682 ip6_del_rt(rt);
1da177e4
LT		 1683 goto restart;
1684 }
1685 }
c71099ac 1686 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1687}
1688
86872cb5
TG		 1689static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1690 struct fib6_config *cfg)
1691{
1692 memset(cfg, 0, sizeof(*cfg));
1693
1694 cfg->fc_table = RT6_TABLE_MAIN;
1695 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1696 cfg->fc_metric = rtmsg->rtmsg_metric;
1697 cfg->fc_expires = rtmsg->rtmsg_info;
1698 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1699 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1700 cfg->fc_flags = rtmsg->rtmsg_flags;
1701
1702 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1703 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1704 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1705}
1706
1da177e4
LT		 1707int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1708{
86872cb5 1709 struct fib6_config cfg;
1da177e4
LT		 1710 struct in6_rtmsg rtmsg;
1711 int err;
1712
1713 switch(cmd) {
1714 case SIOCADDRT: /* Add a route */
1715 case SIOCDELRT: /* Delete a route */
1716 if (!capable(CAP_NET_ADMIN))
1717 return -EPERM;
1718 err = copy_from_user(&rtmsg, arg,
1719 sizeof(struct in6_rtmsg));
1720 if (err)
1721 return -EFAULT;
86872cb5
TG		 1722
1723 rtmsg_to_fib6_config(&rtmsg, &cfg);
1724
1da177e4
LT		 1725 rtnl_lock();
1726 switch (cmd) {
1727 case SIOCADDRT:
86872cb5 1728 err = ip6_route_add(&cfg);
1da177e4
LT		 1729 break;
1730 case SIOCDELRT:
86872cb5 1731 err = ip6_route_del(&cfg);
1da177e4
LT		 1732 break;
1733 default:
1734 err = -EINVAL;
1735 }
1736 rtnl_unlock();
1737
1738 return err;
1739 };
1740
1741 return -EINVAL;
1742}
1743
1744/*
1745 * Drop the packet on the floor
1746 */
1747
9ce8ade0 1748static inline int ip6_pkt_drop(struct sk_buff *skb, int code)
1da177e4 1749{
76d0cc1b
LL		 1750 int type = ipv6_addr_type(&skb->nh.ipv6h->daddr);
1751 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED)
a11d206d 1752 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
76d0cc1b 1753
a11d206d 1754 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_OUTNOROUTES);
9ce8ade0 1755 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1da177e4
LT		 1756 kfree_skb(skb);
1757 return 0;
1758}
1759
9ce8ade0
TG		 1760static int ip6_pkt_discard(struct sk_buff *skb)
1761{
1762 return ip6_pkt_drop(skb, ICMPV6_NOROUTE);
1763}
1764
20380731 1765static int ip6_pkt_discard_out(struct sk_buff *skb)
1da177e4
LT		 1766{
1767 skb->dev = skb->dst->dev;
1768 return ip6_pkt_discard(skb);
1769}
1770
6723ab54
DM		 1771#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1772
9ce8ade0
TG		 1773static int ip6_pkt_prohibit(struct sk_buff *skb)
1774{
1775 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED);
1776}
1777
1778static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1779{
1780 skb->dev = skb->dst->dev;
1781 return ip6_pkt_prohibit(skb);
1782}
1783
1784static int ip6_pkt_blk_hole(struct sk_buff *skb)
1785{
1786 kfree_skb(skb);
1787 return 0;
1788}
1789
6723ab54
DM		 1790#endif
1791
1da177e4
LT		 1792/*
1793 * Allocate a dst for local (unicast / anycast) address.
1794 */
1795
1796struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1797 const struct in6_addr *addr,
1798 int anycast)
1799{
1800 struct rt6_info *rt = ip6_dst_alloc();
1801
1802 if (rt == NULL)
1803 return ERR_PTR(-ENOMEM);
1804
1805 dev_hold(&loopback_dev);
1806 in6_dev_hold(idev);
1807
1808 rt->u.dst.flags = DST_HOST;
1809 rt->u.dst.input = ip6_input;
1810 rt->u.dst.output = ip6_output;
1811 rt->rt6i_dev = &loopback_dev;
1812 rt->rt6i_idev = idev;
1813 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1814 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1815 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1816 rt->u.dst.obsolete = -1;
1817
1818 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 1819 if (anycast)
1820 rt->rt6i_flags |= RTF_ANYCAST;
1821 else
1da177e4
LT		 1822 rt->rt6i_flags |= RTF_LOCAL;
1823 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1824 if (rt->rt6i_nexthop == NULL) {
40aa7b90 1825 dst_free(&rt->u.dst);
1da177e4
LT		 1826 return ERR_PTR(-ENOMEM);
1827 }
1828
1829 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1830 rt->rt6i_dst.plen = 128;
c71099ac 1831 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
1da177e4
LT		 1832
1833 atomic_set(&rt->u.dst.__refcnt, 1);
1834
1835 return rt;
1836}
1837
1838static int fib6_ifdown(struct rt6_info *rt, void *arg)
1839{
1840 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1841 rt != &ip6_null_entry) {
1842 RT6_TRACE("deleted by ifdown %p\n", rt);
1843 return -1;
1844 }
1845 return 0;
1846}
1847
1848void rt6_ifdown(struct net_device *dev)
1849{
c71099ac 1850 fib6_clean_all(fib6_ifdown, 0, dev);
1da177e4
LT		 1851}
1852
1853struct rt6_mtu_change_arg
1854{
1855 struct net_device *dev;
1856 unsigned mtu;
1857};
1858
1859static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1860{
1861 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1862 struct inet6_dev *idev;
1863
1864 /* In IPv6 pmtu discovery is not optional,
1865 so that RTAX_MTU lock cannot disable it.
1866 We still use this lock to block changes
1867 caused by addrconf/ndisc.
1868 */
1869
1870 idev = __in6_dev_get(arg->dev);
1871 if (idev == NULL)
1872 return 0;
1873
1874 /* For administrative MTU increase, there is no way to discover
1875 IPv6 PMTU increase, so PMTU increase should be updated here.
1876 Since RFC 1981 doesn't include administrative MTU increase
1877 update PMTU increase is a MUST. (i.e. jumbo frame)
1878 */
1879 /*
1880 If new MTU is less than route PMTU, this new MTU will be the
1881 lowest MTU in the path, update the route PMTU to reflect PMTU
1882 decreases; if new MTU is greater than route PMTU, and the
1883 old MTU is the lowest MTU in the path, update the route PMTU
1884 to reflect the increase. In this case if the other nodes' MTU
1885 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1886 PMTU discouvery.
1887 */
1888 if (rt->rt6i_dev == arg->dev &&
1889 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1890 (dst_mtu(&rt->u.dst) > arg->mtu ||
1891 (dst_mtu(&rt->u.dst) < arg->mtu &&
1892 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1893 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1894 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1895 return 0;
1896}
1897
1898void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1899{
c71099ac
TG		 1900 struct rt6_mtu_change_arg arg = {
1901 .dev = dev,
1902 .mtu = mtu,
1903 };
1da177e4 1904
c71099ac 1905 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
1da177e4
LT		 1906}
1907
86872cb5 1908static struct nla_policy rtm_ipv6_policy[RTA_MAX+1] __read_mostly = {
5176f91e 1909 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 1910 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 1911 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 1912 [RTA_PRIORITY] = { .type = NLA_U32 },
1913 [RTA_METRICS] = { .type = NLA_NESTED },
1914};
1915
1916static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1917 struct fib6_config *cfg)
1da177e4 1918{
86872cb5
TG		 1919 struct rtmsg *rtm;
1920 struct nlattr *tb[RTA_MAX+1];
1921 int err;
1da177e4 1922
86872cb5
TG		 1923 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1924 if (err < 0)
1925 goto errout;
1da177e4 1926
86872cb5
TG		 1927 err = -EINVAL;
1928 rtm = nlmsg_data(nlh);
1929 memset(cfg, 0, sizeof(*cfg));
1930
1931 cfg->fc_table = rtm->rtm_table;
1932 cfg->fc_dst_len = rtm->rtm_dst_len;
1933 cfg->fc_src_len = rtm->rtm_src_len;
1934 cfg->fc_flags = RTF_UP;
1935 cfg->fc_protocol = rtm->rtm_protocol;
1936
1937 if (rtm->rtm_type == RTN_UNREACHABLE)
1938 cfg->fc_flags |= RTF_REJECT;
1939
1940 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1941 cfg->fc_nlinfo.nlh = nlh;
1942
1943 if (tb[RTA_GATEWAY]) {
1944 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1945 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 1946 }
86872cb5
TG		 1947
1948 if (tb[RTA_DST]) {
1949 int plen = (rtm->rtm_dst_len + 7) >> 3;
1950
1951 if (nla_len(tb[RTA_DST]) < plen)
1952 goto errout;
1953
1954 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 1955 }
86872cb5
TG		 1956
1957 if (tb[RTA_SRC]) {
1958 int plen = (rtm->rtm_src_len + 7) >> 3;
1959
1960 if (nla_len(tb[RTA_SRC]) < plen)
1961 goto errout;
1962
1963 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 1964 }
86872cb5
TG		 1965
1966 if (tb[RTA_OIF])
1967 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1968
1969 if (tb[RTA_PRIORITY])
1970 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1971
1972 if (tb[RTA_METRICS]) {
1973 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
1974 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 1975 }
86872cb5
TG		 1976
1977 if (tb[RTA_TABLE])
1978 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
1979
1980 err = 0;
1981errout:
1982 return err;
1da177e4
LT		 1983}
1984
1985int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1986{
86872cb5
TG		 1987 struct fib6_config cfg;
1988 int err;
1da177e4 1989
86872cb5
TG		 1990 err = rtm_to_fib6_config(skb, nlh, &cfg);
1991 if (err < 0)
1992 return err;
1993
1994 return ip6_route_del(&cfg);
1da177e4
LT		 1995}
1996
1997int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1998{
86872cb5
TG		 1999 struct fib6_config cfg;
2000 int err;
1da177e4 2001
86872cb5
TG		 2002 err = rtm_to_fib6_config(skb, nlh, &cfg);
2003 if (err < 0)
2004 return err;
2005
2006 return ip6_route_add(&cfg);
1da177e4
LT		 2007}
2008
1da177e4 2009static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
0d51aa80
JHS		 2010 struct in6_addr *dst, struct in6_addr *src,
2011 int iif, int type, u32 pid, u32 seq,
2012 int prefix, unsigned int flags)
1da177e4
LT		 2013{
2014 struct rtmsg *rtm;
2d7202bf 2015 struct nlmsghdr *nlh;
1da177e4 2016 struct rta_cacheinfo ci;
9e762a4a 2017 u32 table;
1da177e4
LT		 2018
2019 if (prefix) { /* user wants prefix routes only */
2020 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2021 /* success since this is not a prefix route */
2022 return 1;
2023 }
2024 }
2025
2d7202bf
TG		 2026 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2027 if (nlh == NULL)
2028 return -ENOBUFS;
2029
2030 rtm = nlmsg_data(nlh);
1da177e4
LT		 2031 rtm->rtm_family = AF_INET6;
2032 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2033 rtm->rtm_src_len = rt->rt6i_src.plen;
2034 rtm->rtm_tos = 0;
c71099ac 2035 if (rt->rt6i_table)
9e762a4a 2036 table = rt->rt6i_table->tb6_id;
c71099ac 2037 else
9e762a4a
PM		 2038 table = RT6_TABLE_UNSPEC;
2039 rtm->rtm_table = table;
2d7202bf 2040 NLA_PUT_U32(skb, RTA_TABLE, table);
1da177e4
LT		 2041 if (rt->rt6i_flags&RTF_REJECT)
2042 rtm->rtm_type = RTN_UNREACHABLE;
2043 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2044 rtm->rtm_type = RTN_LOCAL;
2045 else
2046 rtm->rtm_type = RTN_UNICAST;
2047 rtm->rtm_flags = 0;
2048 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2049 rtm->rtm_protocol = rt->rt6i_protocol;
2050 if (rt->rt6i_flags&RTF_DYNAMIC)
2051 rtm->rtm_protocol = RTPROT_REDIRECT;
2052 else if (rt->rt6i_flags & RTF_ADDRCONF)
2053 rtm->rtm_protocol = RTPROT_KERNEL;
2054 else if (rt->rt6i_flags&RTF_DEFAULT)
2055 rtm->rtm_protocol = RTPROT_RA;
2056
2057 if (rt->rt6i_flags&RTF_CACHE)
2058 rtm->rtm_flags |= RTM_F_CLONED;
2059
2060 if (dst) {
2d7202bf 2061 NLA_PUT(skb, RTA_DST, 16, dst);
1da177e4
LT		 2062 rtm->rtm_dst_len = 128;
2063 } else if (rtm->rtm_dst_len)
2d7202bf 2064 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
1da177e4
LT		 2065#ifdef CONFIG_IPV6_SUBTREES
2066 if (src) {
2d7202bf 2067 NLA_PUT(skb, RTA_SRC, 16, src);
1da177e4
LT		 2068 rtm->rtm_src_len = 128;
2069 } else if (rtm->rtm_src_len)
2d7202bf 2070 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
1da177e4
LT		 2071#endif
2072 if (iif)
2d7202bf 2073 NLA_PUT_U32(skb, RTA_IIF, iif);
1da177e4
LT		 2074 else if (dst) {
2075 struct in6_addr saddr_buf;
2076 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
2d7202bf 2077 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
1da177e4 2078 }
2d7202bf 2079
1da177e4 2080 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2d7202bf
TG		 2081 goto nla_put_failure;
2082
1da177e4 2083 if (rt->u.dst.neighbour)
2d7202bf
TG		 2084 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2085
1da177e4 2086 if (rt->u.dst.dev)
2d7202bf
TG		 2087 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2088
2089 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
1da177e4
LT		 2090 ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
2091 if (rt->rt6i_expires)
2092 ci.rta_expires = jiffies_to_clock_t(rt->rt6i_expires - jiffies);
2093 else
2094 ci.rta_expires = 0;
2095 ci.rta_used = rt->u.dst.__use;
2096 ci.rta_clntref = atomic_read(&rt->u.dst.__refcnt);
2097 ci.rta_error = rt->u.dst.error;
2098 ci.rta_id = 0;
2099 ci.rta_ts = 0;
2100 ci.rta_tsage = 0;
2d7202bf
TG		 2101 NLA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
2102
2103 return nlmsg_end(skb, nlh);
2104
2105nla_put_failure:
2106 return nlmsg_cancel(skb, nlh);
1da177e4
LT		 2107}
2108
1b43af54 2109int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 2110{
2111 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2112 int prefix;
2113
2d7202bf
TG		 2114 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2115 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
1da177e4
LT		 2116 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2117 } else
2118 prefix = 0;
2119
2120 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2121 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
0d51aa80 2122 prefix, NLM_F_MULTI);
1da177e4
LT		 2123}
2124
1da177e4
LT		 2125int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2126{
ab364a6f
TG		 2127 struct nlattr *tb[RTA_MAX+1];
2128 struct rt6_info *rt;
1da177e4 2129 struct sk_buff *skb;
ab364a6f 2130 struct rtmsg *rtm;
1da177e4 2131 struct flowi fl;
ab364a6f 2132 int err, iif = 0;
1da177e4 2133
ab364a6f
TG		 2134 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2135 if (err < 0)
2136 goto errout;
1da177e4 2137
ab364a6f 2138 err = -EINVAL;
1da177e4 2139 memset(&fl, 0, sizeof(fl));
1da177e4 2140
ab364a6f
TG		 2141 if (tb[RTA_SRC]) {
2142 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2143 goto errout;
2144
2145 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2146 }
2147
2148 if (tb[RTA_DST]) {
2149 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2150 goto errout;
2151
2152 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2153 }
2154
2155 if (tb[RTA_IIF])
2156 iif = nla_get_u32(tb[RTA_IIF]);
2157
2158 if (tb[RTA_OIF])
2159 fl.oif = nla_get_u32(tb[RTA_OIF]);
1da177e4
LT		 2160
2161 if (iif) {
2162 struct net_device *dev;
2163 dev = __dev_get_by_index(iif);
2164 if (!dev) {
2165 err = -ENODEV;
ab364a6f 2166 goto errout;
1da177e4
LT		 2167 }
2168 }
2169
ab364a6f
TG		 2170 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2171 if (skb == NULL) {
2172 err = -ENOBUFS;
2173 goto errout;
2174 }
1da177e4 2175
ab364a6f
TG		 2176 /* Reserve room for dummy headers, this skb can pass
2177 through good chunk of routing engine.
2178 */
2179 skb->mac.raw = skb->data;
2180 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1da177e4 2181
ab364a6f 2182 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
1da177e4
LT		 2183 skb->dst = &rt->u.dst;
2184
ab364a6f 2185 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
1da177e4 2186 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
0d51aa80 2187 nlh->nlmsg_seq, 0, 0);
1da177e4 2188 if (err < 0) {
ab364a6f
TG		 2189 kfree_skb(skb);
2190 goto errout;
1da177e4
LT		 2191 }
2192
2942e900 2193 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
ab364a6f 2194errout:
1da177e4 2195 return err;
1da177e4
LT		 2196}
2197
86872cb5 2198void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2199{
2200 struct sk_buff *skb;
86872cb5
TG		 2201 u32 pid = 0, seq = 0;
2202 struct nlmsghdr *nlh = NULL;
21713ebc
TG		 2203 int payload = sizeof(struct rtmsg) + 256;
2204 int err = -ENOBUFS;
2205
86872cb5
TG		 2206 if (info) {
2207 pid = info->pid;
2208 nlh = info->nlh;
2209 if (nlh)
2210 seq = nlh->nlmsg_seq;
2211 }
2212
21713ebc
TG		 2213 skb = nlmsg_new(nlmsg_total_size(payload), gfp_any());
2214 if (skb == NULL)
2215 goto errout;
2216
2217 err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
2218 if (err < 0) {
1da177e4 2219 kfree_skb(skb);
21713ebc 2220 goto errout;
1da177e4 2221 }
21713ebc
TG		 2222
2223 err = rtnl_notify(skb, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2224errout:
2225 if (err < 0)
2226 rtnl_set_sk_err(RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 2227}
2228
2229/*
2230 * /proc
2231 */
2232
2233#ifdef CONFIG_PROC_FS
2234
2235#define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2236
2237struct rt6_proc_arg
2238{
2239 char *buffer;
2240 int offset;
2241 int length;
2242 int skip;
2243 int len;
2244};
2245
2246static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2247{
2248 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
1da177e4
LT		 2249
2250 if (arg->skip < arg->offset / RT6_INFO_LEN) {
2251 arg->skip++;
2252 return 0;
2253 }
2254
2255 if (arg->len >= arg->length)
2256 return 0;
2257
33e93c96
YH		 2258 arg->len += sprintf(arg->buffer + arg->len,
2259 NIP6_SEQFMT " %02x ",
2260 NIP6(rt->rt6i_dst.addr),
1da177e4
LT		 2261 rt->rt6i_dst.plen);
2262
2263#ifdef CONFIG_IPV6_SUBTREES
33e93c96
YH		 2264 arg->len += sprintf(arg->buffer + arg->len,
2265 NIP6_SEQFMT " %02x ",
2266 NIP6(rt->rt6i_src.addr),
1da177e4
LT		 2267 rt->rt6i_src.plen);
2268#else
33e93c96
YH		 2269 arg->len += sprintf(arg->buffer + arg->len,
2270 "00000000000000000000000000000000 00 ");
1da177e4
LT		 2271#endif
2272
2273 if (rt->rt6i_nexthop) {
33e93c96
YH		 2274 arg->len += sprintf(arg->buffer + arg->len,
2275 NIP6_SEQFMT,
2276 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
1da177e4 2277 } else {
33e93c96
YH		 2278 arg->len += sprintf(arg->buffer + arg->len,
2279 "00000000000000000000000000000000");
1da177e4
LT		 2280 }
2281 arg->len += sprintf(arg->buffer + arg->len,
2282 " %08x %08x %08x %08x %8s\n",
2283 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2284 rt->u.dst.__use, rt->rt6i_flags,
2285 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2286 return 0;
2287}
2288
2289static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
2290{
c71099ac
TG		 2291 struct rt6_proc_arg arg = {
2292 .buffer = buffer,
2293 .offset = offset,
2294 .length = length,
2295 };
1da177e4 2296
c71099ac 2297 fib6_clean_all(rt6_info_route, 0, &arg);
1da177e4
LT		 2298
2299 *start = buffer;
2300 if (offset)
2301 *start += offset % RT6_INFO_LEN;
2302
2303 arg.len -= offset % RT6_INFO_LEN;
2304
2305 if (arg.len > length)
2306 arg.len = length;
2307 if (arg.len < 0)
2308 arg.len = 0;
2309
2310 return arg.len;
2311}
2312
1da177e4
LT		 2313static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2314{
2315 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2316 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2317 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2318 rt6_stats.fib_rt_cache,
2319 atomic_read(&ip6_dst_ops.entries),
2320 rt6_stats.fib_discarded_routes);
2321
2322 return 0;
2323}
2324
2325static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2326{
2327 return single_open(file, rt6_stats_seq_show, NULL);
2328}
2329
2330static struct file_operations rt6_stats_seq_fops = {
2331 .owner = THIS_MODULE,
2332 .open = rt6_stats_seq_open,
2333 .read = seq_read,
2334 .llseek = seq_lseek,
2335 .release = single_release,
2336};
2337#endif /* CONFIG_PROC_FS */
2338
2339#ifdef CONFIG_SYSCTL
2340
2341static int flush_delay;
2342
2343static
2344int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2345 void __user *buffer, size_t *lenp, loff_t *ppos)
2346{
2347 if (write) {
2348 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2349 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2350 return 0;
2351 } else
2352 return -EINVAL;
2353}
2354
2355ctl_table ipv6_route_table[] = {
2356 {
2357 .ctl_name = NET_IPV6_ROUTE_FLUSH,
2358 .procname = "flush",
2359 .data = &flush_delay,
2360 .maxlen = sizeof(int),
89c8b3a1 2361 .mode = 0200,
1da177e4
LT		 2362 .proc_handler = &ipv6_sysctl_rtcache_flush
2363 },
2364 {
2365 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2366 .procname = "gc_thresh",
2367 .data = &ip6_dst_ops.gc_thresh,
2368 .maxlen = sizeof(int),
2369 .mode = 0644,
2370 .proc_handler = &proc_dointvec,
2371 },
2372 {
2373 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2374 .procname = "max_size",
2375 .data = &ip6_rt_max_size,
2376 .maxlen = sizeof(int),
2377 .mode = 0644,
2378 .proc_handler = &proc_dointvec,
2379 },
2380 {
2381 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2382 .procname = "gc_min_interval",
2383 .data = &ip6_rt_gc_min_interval,
2384 .maxlen = sizeof(int),
2385 .mode = 0644,
2386 .proc_handler = &proc_dointvec_jiffies,
2387 .strategy = &sysctl_jiffies,
2388 },
2389 {
2390 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2391 .procname = "gc_timeout",
2392 .data = &ip6_rt_gc_timeout,
2393 .maxlen = sizeof(int),
2394 .mode = 0644,
2395 .proc_handler = &proc_dointvec_jiffies,
2396 .strategy = &sysctl_jiffies,
2397 },
2398 {
2399 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2400 .procname = "gc_interval",
2401 .data = &ip6_rt_gc_interval,
2402 .maxlen = sizeof(int),
2403 .mode = 0644,
2404 .proc_handler = &proc_dointvec_jiffies,
2405 .strategy = &sysctl_jiffies,
2406 },
2407 {
2408 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2409 .procname = "gc_elasticity",
2410 .data = &ip6_rt_gc_elasticity,
2411 .maxlen = sizeof(int),
2412 .mode = 0644,
2413 .proc_handler = &proc_dointvec_jiffies,
2414 .strategy = &sysctl_jiffies,
2415 },
2416 {
2417 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2418 .procname = "mtu_expires",
2419 .data = &ip6_rt_mtu_expires,
2420 .maxlen = sizeof(int),
2421 .mode = 0644,
2422 .proc_handler = &proc_dointvec_jiffies,
2423 .strategy = &sysctl_jiffies,
2424 },
2425 {
2426 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2427 .procname = "min_adv_mss",
2428 .data = &ip6_rt_min_advmss,
2429 .maxlen = sizeof(int),
2430 .mode = 0644,
2431 .proc_handler = &proc_dointvec_jiffies,
2432 .strategy = &sysctl_jiffies,
2433 },
2434 {
2435 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2436 .procname = "gc_min_interval_ms",
2437 .data = &ip6_rt_gc_min_interval,
2438 .maxlen = sizeof(int),
2439 .mode = 0644,
2440 .proc_handler = &proc_dointvec_ms_jiffies,
2441 .strategy = &sysctl_ms_jiffies,
2442 },
2443 { .ctl_name = 0 }
2444};
2445
2446#endif
2447
2448void __init ip6_route_init(void)
2449{
2450 struct proc_dir_entry *p;
2451
e5d679f3
AD		 2452 ip6_dst_ops.kmem_cachep =
2453 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2454 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1da177e4
LT		 2455 fib6_init();
2456#ifdef CONFIG_PROC_FS
2457 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2458 if (p)
2459 p->owner = THIS_MODULE;
2460
2461 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2462#endif
2463#ifdef CONFIG_XFRM
2464 xfrm6_init();
2465#endif
101367c2
TG		 2466#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2467 fib6_rules_init();
2468#endif
1da177e4
LT		 2469}
2470
2471void ip6_route_cleanup(void)
2472{
101367c2
TG		 2473#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2474 fib6_rules_cleanup();
2475#endif
1da177e4
LT		 2476#ifdef CONFIG_PROC_FS
2477 proc_net_remove("ipv6_route");
2478 proc_net_remove("rt6_stats");
2479#endif
2480#ifdef CONFIG_XFRM
2481 xfrm6_fini();
2482#endif
2483 rt6_ifdown(NULL);
2484 fib6_gc_cleanup();
2485 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2486}
kernel source for telekom puls (alcatel/mediatek)