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