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