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