projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'for-v3.7' of git://git.infradead.org/users/cbou/linux-pstore
[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 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14 /* Changes:
15 *
16 * YOSHIFUJI Hideaki @USAGI
17 * reworked default router selection.
18 * - respect outgoing interface
19 * - select from (probably) reachable routers (i.e.
20 * routers in REACHABLE, STALE, DELAY or PROBE states).
21 * - always select the same router if it is (probably)
22 * reachable. otherwise, round-robin the list.
23 * Ville Nuorvala
24 * Fixed routing subtrees.
25 */
26
27 #define pr_fmt(fmt) "IPv6: " fmt
28
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/export.h>
32 #include <linux/types.h>
33 #include <linux/times.h>
34 #include <linux/socket.h>
35 #include <linux/sockios.h>
36 #include <linux/net.h>
37 #include <linux/route.h>
38 #include <linux/netdevice.h>
39 #include <linux/in6.h>
40 #include <linux/mroute6.h>
41 #include <linux/init.h>
42 #include <linux/if_arp.h>
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
45 #include <linux/nsproxy.h>
46 #include <linux/slab.h>
47 #include <net/net_namespace.h>
48 #include <net/snmp.h>
49 #include <net/ipv6.h>
50 #include <net/ip6_fib.h>
51 #include <net/ip6_route.h>
52 #include <net/ndisc.h>
53 #include <net/addrconf.h>
54 #include <net/tcp.h>
55 #include <linux/rtnetlink.h>
56 #include <net/dst.h>
57 #include <net/xfrm.h>
58 #include <net/netevent.h>
59 #include <net/netlink.h>
60
61 #include <asm/uaccess.h>
62
63 #ifdef CONFIG_SYSCTL
64 #include <linux/sysctl.h>
65 #endif
66
67 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
68 const struct in6_addr *dest);
69 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
70 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
71 static unsigned int ip6_mtu(const struct dst_entry *dst);
72 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
73 static void ip6_dst_destroy(struct dst_entry *);
74 static void ip6_dst_ifdown(struct dst_entry *,
75 struct net_device *dev, int how);
76 static int ip6_dst_gc(struct dst_ops *ops);
77
78 static int ip6_pkt_discard(struct sk_buff *skb);
79 static int ip6_pkt_discard_out(struct sk_buff *skb);
80 static void ip6_link_failure(struct sk_buff *skb);
81 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
82 struct sk_buff *skb, u32 mtu);
83 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
84 struct sk_buff *skb);
85
86 #ifdef CONFIG_IPV6_ROUTE_INFO
87 static struct rt6_info *rt6_add_route_info(struct net *net,
88 const struct in6_addr *prefix, int prefixlen,
89 const struct in6_addr *gwaddr, int ifindex,
90 unsigned int pref);
91 static struct rt6_info *rt6_get_route_info(struct net *net,
92 const struct in6_addr *prefix, int prefixlen,
93 const struct in6_addr *gwaddr, int ifindex);
94 #endif
95
96 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
97 {
98 struct rt6_info *rt = (struct rt6_info *) dst;
99 struct inet_peer *peer;
100 u32 *p = NULL;
101
102 if (!(rt->dst.flags & DST_HOST))
103 return NULL;
104
105 peer = rt6_get_peer_create(rt);
106 if (peer) {
107 u32 *old_p = __DST_METRICS_PTR(old);
108 unsigned long prev, new;
109
110 p = peer->metrics;
111 if (inet_metrics_new(peer))
112 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
113
114 new = (unsigned long) p;
115 prev = cmpxchg(&dst->_metrics, old, new);
116
117 if (prev != old) {
118 p = __DST_METRICS_PTR(prev);
119 if (prev & DST_METRICS_READ_ONLY)
120 p = NULL;
121 }
122 }
123 return p;
124 }
125
126 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
127 struct sk_buff *skb,
128 const void *daddr)
129 {
130 struct in6_addr *p = &rt->rt6i_gateway;
131
132 if (!ipv6_addr_any(p))
133 return (const void *) p;
134 else if (skb)
135 return &ipv6_hdr(skb)->daddr;
136 return daddr;
137 }
138
139 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
140 struct sk_buff *skb,
141 const void *daddr)
142 {
143 struct rt6_info *rt = (struct rt6_info *) dst;
144 struct neighbour *n;
145
146 daddr = choose_neigh_daddr(rt, skb, daddr);
147 n = __ipv6_neigh_lookup(&nd_tbl, dst->dev, daddr);
148 if (n)
149 return n;
150 return neigh_create(&nd_tbl, daddr, dst->dev);
151 }
152
153 static int rt6_bind_neighbour(struct rt6_info *rt, struct net_device *dev)
154 {
155 struct neighbour *n = __ipv6_neigh_lookup(&nd_tbl, dev, &rt->rt6i_gateway);
156 if (!n) {
157 n = neigh_create(&nd_tbl, &rt->rt6i_gateway, dev);
158 if (IS_ERR(n))
159 return PTR_ERR(n);
160 }
161 rt->n = n;
162
163 return 0;
164 }
165
166 static struct dst_ops ip6_dst_ops_template = {
167 .family = AF_INET6,
168 .protocol = cpu_to_be16(ETH_P_IPV6),
169 .gc = ip6_dst_gc,
170 .gc_thresh = 1024,
171 .check = ip6_dst_check,
172 .default_advmss = ip6_default_advmss,
173 .mtu = ip6_mtu,
174 .cow_metrics = ipv6_cow_metrics,
175 .destroy = ip6_dst_destroy,
176 .ifdown = ip6_dst_ifdown,
177 .negative_advice = ip6_negative_advice,
178 .link_failure = ip6_link_failure,
179 .update_pmtu = ip6_rt_update_pmtu,
180 .redirect = rt6_do_redirect,
181 .local_out = __ip6_local_out,
182 .neigh_lookup = ip6_neigh_lookup,
183 };
184
185 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
186 {
187 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
188
189 return mtu ? : dst->dev->mtu;
190 }
191
192 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
193 struct sk_buff *skb, u32 mtu)
194 {
195 }
196
197 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
198 struct sk_buff *skb)
199 {
200 }
201
202 static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,
203 unsigned long old)
204 {
205 return NULL;
206 }
207
208 static struct dst_ops ip6_dst_blackhole_ops = {
209 .family = AF_INET6,
210 .protocol = cpu_to_be16(ETH_P_IPV6),
211 .destroy = ip6_dst_destroy,
212 .check = ip6_dst_check,
213 .mtu = ip6_blackhole_mtu,
214 .default_advmss = ip6_default_advmss,
215 .update_pmtu = ip6_rt_blackhole_update_pmtu,
216 .redirect = ip6_rt_blackhole_redirect,
217 .cow_metrics = ip6_rt_blackhole_cow_metrics,
218 .neigh_lookup = ip6_neigh_lookup,
219 };
220
221 static const u32 ip6_template_metrics[RTAX_MAX] = {
222 [RTAX_HOPLIMIT - 1] = 255,
223 };
224
225 static const struct rt6_info ip6_null_entry_template = {
226 .dst = {
227 .__refcnt = ATOMIC_INIT(1),
228 .__use = 1,
229 .obsolete = DST_OBSOLETE_FORCE_CHK,
230 .error = -ENETUNREACH,
231 .input = ip6_pkt_discard,
232 .output = ip6_pkt_discard_out,
233 },
234 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
235 .rt6i_protocol = RTPROT_KERNEL,
236 .rt6i_metric = ~(u32) 0,
237 .rt6i_ref = ATOMIC_INIT(1),
238 };
239
240 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
241
242 static int ip6_pkt_prohibit(struct sk_buff *skb);
243 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
244
245 static const struct rt6_info ip6_prohibit_entry_template = {
246 .dst = {
247 .__refcnt = ATOMIC_INIT(1),
248 .__use = 1,
249 .obsolete = DST_OBSOLETE_FORCE_CHK,
250 .error = -EACCES,
251 .input = ip6_pkt_prohibit,
252 .output = ip6_pkt_prohibit_out,
253 },
254 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
255 .rt6i_protocol = RTPROT_KERNEL,
256 .rt6i_metric = ~(u32) 0,
257 .rt6i_ref = ATOMIC_INIT(1),
258 };
259
260 static const struct rt6_info ip6_blk_hole_entry_template = {
261 .dst = {
262 .__refcnt = ATOMIC_INIT(1),
263 .__use = 1,
264 .obsolete = DST_OBSOLETE_FORCE_CHK,
265 .error = -EINVAL,
266 .input = dst_discard,
267 .output = dst_discard,
268 },
269 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
270 .rt6i_protocol = RTPROT_KERNEL,
271 .rt6i_metric = ~(u32) 0,
272 .rt6i_ref = ATOMIC_INIT(1),
273 };
274
275 #endif
276
277 /* allocate dst with ip6_dst_ops */
278 static inline struct rt6_info *ip6_dst_alloc(struct net *net,
279 struct net_device *dev,
280 int flags,
281 struct fib6_table *table)
282 {
283 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
284 0, DST_OBSOLETE_FORCE_CHK, flags);
285
286 if (rt) {
287 struct dst_entry *dst = &rt->dst;
288
289 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
290 rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);
291 rt->rt6i_genid = rt_genid(net);
292 }
293 return rt;
294 }
295
296 static void ip6_dst_destroy(struct dst_entry *dst)
297 {
298 struct rt6_info *rt = (struct rt6_info *)dst;
299 struct inet6_dev *idev = rt->rt6i_idev;
300
301 if (rt->n)
302 neigh_release(rt->n);
303
304 if (!(rt->dst.flags & DST_HOST))
305 dst_destroy_metrics_generic(dst);
306
307 if (idev) {
308 rt->rt6i_idev = NULL;
309 in6_dev_put(idev);
310 }
311
312 if (!(rt->rt6i_flags & RTF_EXPIRES) && dst->from)
313 dst_release(dst->from);
314
315 if (rt6_has_peer(rt)) {
316 struct inet_peer *peer = rt6_peer_ptr(rt);
317 inet_putpeer(peer);
318 }
319 }
320
321 static atomic_t __rt6_peer_genid = ATOMIC_INIT(0);
322
323 static u32 rt6_peer_genid(void)
324 {
325 return atomic_read(&__rt6_peer_genid);
326 }
327
328 void rt6_bind_peer(struct rt6_info *rt, int create)
329 {
330 struct inet_peer_base *base;
331 struct inet_peer *peer;
332
333 base = inetpeer_base_ptr(rt->_rt6i_peer);
334 if (!base)
335 return;
336
337 peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);
338 if (peer) {
339 if (!rt6_set_peer(rt, peer))
340 inet_putpeer(peer);
341 else
342 rt->rt6i_peer_genid = rt6_peer_genid();
343 }
344 }
345
346 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
347 int how)
348 {
349 struct rt6_info *rt = (struct rt6_info *)dst;
350 struct inet6_dev *idev = rt->rt6i_idev;
351 struct net_device *loopback_dev =
352 dev_net(dev)->loopback_dev;
353
354 if (dev != loopback_dev) {
355 if (idev && idev->dev == dev) {
356 struct inet6_dev *loopback_idev =
357 in6_dev_get(loopback_dev);
358 if (loopback_idev) {
359 rt->rt6i_idev = loopback_idev;
360 in6_dev_put(idev);
361 }
362 }
363 if (rt->n && rt->n->dev == dev) {
364 rt->n->dev = loopback_dev;
365 dev_hold(loopback_dev);
366 dev_put(dev);
367 }
368 }
369 }
370
371 static bool rt6_check_expired(const struct rt6_info *rt)
372 {
373 if (rt->rt6i_flags & RTF_EXPIRES) {
374 if (time_after(jiffies, rt->dst.expires))
375 return true;
376 } else if (rt->dst.from) {
377 return rt6_check_expired((struct rt6_info *) rt->dst.from);
378 }
379 return false;
380 }
381
382 static bool rt6_need_strict(const struct in6_addr *daddr)
383 {
384 return ipv6_addr_type(daddr) &
385 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
386 }
387
388 /*
389 * Route lookup. Any table->tb6_lock is implied.
390 */
391
392 static inline struct rt6_info *rt6_device_match(struct net *net,
393 struct rt6_info *rt,
394 const struct in6_addr *saddr,
395 int oif,
396 int flags)
397 {
398 struct rt6_info *local = NULL;
399 struct rt6_info *sprt;
400
401 if (!oif && ipv6_addr_any(saddr))
402 goto out;
403
404 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
405 struct net_device *dev = sprt->dst.dev;
406
407 if (oif) {
408 if (dev->ifindex == oif)
409 return sprt;
410 if (dev->flags & IFF_LOOPBACK) {
411 if (!sprt->rt6i_idev ||
412 sprt->rt6i_idev->dev->ifindex != oif) {
413 if (flags & RT6_LOOKUP_F_IFACE && oif)
414 continue;
415 if (local && (!oif ||
416 local->rt6i_idev->dev->ifindex == oif))
417 continue;
418 }
419 local = sprt;
420 }
421 } else {
422 if (ipv6_chk_addr(net, saddr, dev,
423 flags & RT6_LOOKUP_F_IFACE))
424 return sprt;
425 }
426 }
427
428 if (oif) {
429 if (local)
430 return local;
431
432 if (flags & RT6_LOOKUP_F_IFACE)
433 return net->ipv6.ip6_null_entry;
434 }
435 out:
436 return rt;
437 }
438
439 #ifdef CONFIG_IPV6_ROUTER_PREF
440 static void rt6_probe(struct rt6_info *rt)
441 {
442 struct neighbour *neigh;
443 /*
444 * Okay, this does not seem to be appropriate
445 * for now, however, we need to check if it
446 * is really so; aka Router Reachability Probing.
447 *
448 * Router Reachability Probe MUST be rate-limited
449 * to no more than one per minute.
450 */
451 neigh = rt ? rt->n : NULL;
452 if (!neigh || (neigh->nud_state & NUD_VALID))
453 return;
454 read_lock_bh(&neigh->lock);
455 if (!(neigh->nud_state & NUD_VALID) &&
456 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
457 struct in6_addr mcaddr;
458 struct in6_addr *target;
459
460 neigh->updated = jiffies;
461 read_unlock_bh(&neigh->lock);
462
463 target = (struct in6_addr *)&neigh->primary_key;
464 addrconf_addr_solict_mult(target, &mcaddr);
465 ndisc_send_ns(rt->dst.dev, NULL, target, &mcaddr, NULL);
466 } else {
467 read_unlock_bh(&neigh->lock);
468 }
469 }
470 #else
471 static inline void rt6_probe(struct rt6_info *rt)
472 {
473 }
474 #endif
475
476 /*
477 * Default Router Selection (RFC 2461 6.3.6)
478 */
479 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
480 {
481 struct net_device *dev = rt->dst.dev;
482 if (!oif || dev->ifindex == oif)
483 return 2;
484 if ((dev->flags & IFF_LOOPBACK) &&
485 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
486 return 1;
487 return 0;
488 }
489
490 static inline int rt6_check_neigh(struct rt6_info *rt)
491 {
492 struct neighbour *neigh;
493 int m;
494
495 neigh = rt->n;
496 if (rt->rt6i_flags & RTF_NONEXTHOP ||
497 !(rt->rt6i_flags & RTF_GATEWAY))
498 m = 1;
499 else if (neigh) {
500 read_lock_bh(&neigh->lock);
501 if (neigh->nud_state & NUD_VALID)
502 m = 2;
503 #ifdef CONFIG_IPV6_ROUTER_PREF
504 else if (neigh->nud_state & NUD_FAILED)
505 m = 0;
506 #endif
507 else
508 m = 1;
509 read_unlock_bh(&neigh->lock);
510 } else
511 m = 0;
512 return m;
513 }
514
515 static int rt6_score_route(struct rt6_info *rt, int oif,
516 int strict)
517 {
518 int m, n;
519
520 m = rt6_check_dev(rt, oif);
521 if (!m && (strict & RT6_LOOKUP_F_IFACE))
522 return -1;
523 #ifdef CONFIG_IPV6_ROUTER_PREF
524 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
525 #endif
526 n = rt6_check_neigh(rt);
527 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
528 return -1;
529 return m;
530 }
531
532 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
533 int *mpri, struct rt6_info *match)
534 {
535 int m;
536
537 if (rt6_check_expired(rt))
538 goto out;
539
540 m = rt6_score_route(rt, oif, strict);
541 if (m < 0)
542 goto out;
543
544 if (m > *mpri) {
545 if (strict & RT6_LOOKUP_F_REACHABLE)
546 rt6_probe(match);
547 *mpri = m;
548 match = rt;
549 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
550 rt6_probe(rt);
551 }
552
553 out:
554 return match;
555 }
556
557 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
558 struct rt6_info *rr_head,
559 u32 metric, int oif, int strict)
560 {
561 struct rt6_info *rt, *match;
562 int mpri = -1;
563
564 match = NULL;
565 for (rt = rr_head; rt && rt->rt6i_metric == metric;
566 rt = rt->dst.rt6_next)
567 match = find_match(rt, oif, strict, &mpri, match);
568 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
569 rt = rt->dst.rt6_next)
570 match = find_match(rt, oif, strict, &mpri, match);
571
572 return match;
573 }
574
575 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
576 {
577 struct rt6_info *match, *rt0;
578 struct net *net;
579
580 rt0 = fn->rr_ptr;
581 if (!rt0)
582 fn->rr_ptr = rt0 = fn->leaf;
583
584 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
585
586 if (!match &&
587 (strict & RT6_LOOKUP_F_REACHABLE)) {
588 struct rt6_info *next = rt0->dst.rt6_next;
589
590 /* no entries matched; do round-robin */
591 if (!next || next->rt6i_metric != rt0->rt6i_metric)
592 next = fn->leaf;
593
594 if (next != rt0)
595 fn->rr_ptr = next;
596 }
597
598 net = dev_net(rt0->dst.dev);
599 return match ? match : net->ipv6.ip6_null_entry;
600 }
601
602 #ifdef CONFIG_IPV6_ROUTE_INFO
603 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
604 const struct in6_addr *gwaddr)
605 {
606 struct net *net = dev_net(dev);
607 struct route_info *rinfo = (struct route_info *) opt;
608 struct in6_addr prefix_buf, *prefix;
609 unsigned int pref;
610 unsigned long lifetime;
611 struct rt6_info *rt;
612
613 if (len < sizeof(struct route_info)) {
614 return -EINVAL;
615 }
616
617 /* Sanity check for prefix_len and length */
618 if (rinfo->length > 3) {
619 return -EINVAL;
620 } else if (rinfo->prefix_len > 128) {
621 return -EINVAL;
622 } else if (rinfo->prefix_len > 64) {
623 if (rinfo->length < 2) {
624 return -EINVAL;
625 }
626 } else if (rinfo->prefix_len > 0) {
627 if (rinfo->length < 1) {
628 return -EINVAL;
629 }
630 }
631
632 pref = rinfo->route_pref;
633 if (pref == ICMPV6_ROUTER_PREF_INVALID)
634 return -EINVAL;
635
636 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
637
638 if (rinfo->length == 3)
639 prefix = (struct in6_addr *)rinfo->prefix;
640 else {
641 /* this function is safe */
642 ipv6_addr_prefix(&prefix_buf,
643 (struct in6_addr *)rinfo->prefix,
644 rinfo->prefix_len);
645 prefix = &prefix_buf;
646 }
647
648 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
649 dev->ifindex);
650
651 if (rt && !lifetime) {
652 ip6_del_rt(rt);
653 rt = NULL;
654 }
655
656 if (!rt && lifetime)
657 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
658 pref);
659 else if (rt)
660 rt->rt6i_flags = RTF_ROUTEINFO |
661 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
662
663 if (rt) {
664 if (!addrconf_finite_timeout(lifetime))
665 rt6_clean_expires(rt);
666 else
667 rt6_set_expires(rt, jiffies + HZ * lifetime);
668
669 dst_release(&rt->dst);
670 }
671 return 0;
672 }
673 #endif
674
675 #define BACKTRACK(__net, saddr) \
676 do { \
677 if (rt == __net->ipv6.ip6_null_entry) { \
678 struct fib6_node *pn; \
679 while (1) { \
680 if (fn->fn_flags & RTN_TL_ROOT) \
681 goto out; \
682 pn = fn->parent; \
683 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
684 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
685 else \
686 fn = pn; \
687 if (fn->fn_flags & RTN_RTINFO) \
688 goto restart; \
689 } \
690 } \
691 } while (0)
692
693 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
694 struct fib6_table *table,
695 struct flowi6 *fl6, int flags)
696 {
697 struct fib6_node *fn;
698 struct rt6_info *rt;
699
700 read_lock_bh(&table->tb6_lock);
701 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
702 restart:
703 rt = fn->leaf;
704 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
705 BACKTRACK(net, &fl6->saddr);
706 out:
707 dst_use(&rt->dst, jiffies);
708 read_unlock_bh(&table->tb6_lock);
709 return rt;
710
711 }
712
713 struct dst_entry * ip6_route_lookup(struct net *net, struct flowi6 *fl6,
714 int flags)
715 {
716 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
717 }
718 EXPORT_SYMBOL_GPL(ip6_route_lookup);
719
720 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
721 const struct in6_addr *saddr, int oif, int strict)
722 {
723 struct flowi6 fl6 = {
724 .flowi6_oif = oif,
725 .daddr = *daddr,
726 };
727 struct dst_entry *dst;
728 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
729
730 if (saddr) {
731 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
732 flags |= RT6_LOOKUP_F_HAS_SADDR;
733 }
734
735 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
736 if (dst->error == 0)
737 return (struct rt6_info *) dst;
738
739 dst_release(dst);
740
741 return NULL;
742 }
743
744 EXPORT_SYMBOL(rt6_lookup);
745
746 /* ip6_ins_rt is called with FREE table->tb6_lock.
747 It takes new route entry, the addition fails by any reason the
748 route is freed. In any case, if caller does not hold it, it may
749 be destroyed.
750 */
751
752 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
753 {
754 int err;
755 struct fib6_table *table;
756
757 table = rt->rt6i_table;
758 write_lock_bh(&table->tb6_lock);
759 err = fib6_add(&table->tb6_root, rt, info);
760 write_unlock_bh(&table->tb6_lock);
761
762 return err;
763 }
764
765 int ip6_ins_rt(struct rt6_info *rt)
766 {
767 struct nl_info info = {
768 .nl_net = dev_net(rt->dst.dev),
769 };
770 return __ip6_ins_rt(rt, &info);
771 }
772
773 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,
774 const struct in6_addr *daddr,
775 const struct in6_addr *saddr)
776 {
777 struct rt6_info *rt;
778
779 /*
780 * Clone the route.
781 */
782
783 rt = ip6_rt_copy(ort, daddr);
784
785 if (rt) {
786 int attempts = !in_softirq();
787
788 if (!(rt->rt6i_flags & RTF_GATEWAY)) {
789 if (ort->rt6i_dst.plen != 128 &&
790 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
791 rt->rt6i_flags |= RTF_ANYCAST;
792 rt->rt6i_gateway = *daddr;
793 }
794
795 rt->rt6i_flags |= RTF_CACHE;
796
797 #ifdef CONFIG_IPV6_SUBTREES
798 if (rt->rt6i_src.plen && saddr) {
799 rt->rt6i_src.addr = *saddr;
800 rt->rt6i_src.plen = 128;
801 }
802 #endif
803
804 retry:
805 if (rt6_bind_neighbour(rt, rt->dst.dev)) {
806 struct net *net = dev_net(rt->dst.dev);
807 int saved_rt_min_interval =
808 net->ipv6.sysctl.ip6_rt_gc_min_interval;
809 int saved_rt_elasticity =
810 net->ipv6.sysctl.ip6_rt_gc_elasticity;
811
812 if (attempts-- > 0) {
813 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
814 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
815
816 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
817
818 net->ipv6.sysctl.ip6_rt_gc_elasticity =
819 saved_rt_elasticity;
820 net->ipv6.sysctl.ip6_rt_gc_min_interval =
821 saved_rt_min_interval;
822 goto retry;
823 }
824
825 net_warn_ratelimited("Neighbour table overflow\n");
826 dst_free(&rt->dst);
827 return NULL;
828 }
829 }
830
831 return rt;
832 }
833
834 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,
835 const struct in6_addr *daddr)
836 {
837 struct rt6_info *rt = ip6_rt_copy(ort, daddr);
838
839 if (rt) {
840 rt->rt6i_flags |= RTF_CACHE;
841 rt->n = neigh_clone(ort->n);
842 }
843 return rt;
844 }
845
846 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
847 struct flowi6 *fl6, int flags)
848 {
849 struct fib6_node *fn;
850 struct rt6_info *rt, *nrt;
851 int strict = 0;
852 int attempts = 3;
853 int err;
854 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
855
856 strict |= flags & RT6_LOOKUP_F_IFACE;
857
858 relookup:
859 read_lock_bh(&table->tb6_lock);
860
861 restart_2:
862 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
863
864 restart:
865 rt = rt6_select(fn, oif, strict | reachable);
866
867 BACKTRACK(net, &fl6->saddr);
868 if (rt == net->ipv6.ip6_null_entry ||
869 rt->rt6i_flags & RTF_CACHE)
870 goto out;
871
872 dst_hold(&rt->dst);
873 read_unlock_bh(&table->tb6_lock);
874
875 if (!rt->n && !(rt->rt6i_flags & RTF_NONEXTHOP))
876 nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);
877 else if (!(rt->dst.flags & DST_HOST))
878 nrt = rt6_alloc_clone(rt, &fl6->daddr);
879 else
880 goto out2;
881
882 dst_release(&rt->dst);
883 rt = nrt ? : net->ipv6.ip6_null_entry;
884
885 dst_hold(&rt->dst);
886 if (nrt) {
887 err = ip6_ins_rt(nrt);
888 if (!err)
889 goto out2;
890 }
891
892 if (--attempts <= 0)
893 goto out2;
894
895 /*
896 * Race condition! In the gap, when table->tb6_lock was
897 * released someone could insert this route. Relookup.
898 */
899 dst_release(&rt->dst);
900 goto relookup;
901
902 out:
903 if (reachable) {
904 reachable = 0;
905 goto restart_2;
906 }
907 dst_hold(&rt->dst);
908 read_unlock_bh(&table->tb6_lock);
909 out2:
910 rt->dst.lastuse = jiffies;
911 rt->dst.__use++;
912
913 return rt;
914 }
915
916 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
917 struct flowi6 *fl6, int flags)
918 {
919 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
920 }
921
922 static struct dst_entry *ip6_route_input_lookup(struct net *net,
923 struct net_device *dev,
924 struct flowi6 *fl6, int flags)
925 {
926 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
927 flags |= RT6_LOOKUP_F_IFACE;
928
929 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
930 }
931
932 void ip6_route_input(struct sk_buff *skb)
933 {
934 const struct ipv6hdr *iph = ipv6_hdr(skb);
935 struct net *net = dev_net(skb->dev);
936 int flags = RT6_LOOKUP_F_HAS_SADDR;
937 struct flowi6 fl6 = {
938 .flowi6_iif = skb->dev->ifindex,
939 .daddr = iph->daddr,
940 .saddr = iph->saddr,
941 .flowlabel = (* (__be32 *) iph) & IPV6_FLOWINFO_MASK,
942 .flowi6_mark = skb->mark,
943 .flowi6_proto = iph->nexthdr,
944 };
945
946 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
947 }
948
949 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
950 struct flowi6 *fl6, int flags)
951 {
952 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
953 }
954
955 struct dst_entry * ip6_route_output(struct net *net, const struct sock *sk,
956 struct flowi6 *fl6)
957 {
958 int flags = 0;
959
960 fl6->flowi6_iif = LOOPBACK_IFINDEX;
961
962 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))
963 flags |= RT6_LOOKUP_F_IFACE;
964
965 if (!ipv6_addr_any(&fl6->saddr))
966 flags |= RT6_LOOKUP_F_HAS_SADDR;
967 else if (sk)
968 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
969
970 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
971 }
972
973 EXPORT_SYMBOL(ip6_route_output);
974
975 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
976 {
977 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
978 struct dst_entry *new = NULL;
979
980 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
981 if (rt) {
982 new = &rt->dst;
983
984 memset(new + 1, 0, sizeof(*rt) - sizeof(*new));
985 rt6_init_peer(rt, net->ipv6.peers);
986
987 new->__use = 1;
988 new->input = dst_discard;
989 new->output = dst_discard;
990
991 if (dst_metrics_read_only(&ort->dst))
992 new->_metrics = ort->dst._metrics;
993 else
994 dst_copy_metrics(new, &ort->dst);
995 rt->rt6i_idev = ort->rt6i_idev;
996 if (rt->rt6i_idev)
997 in6_dev_hold(rt->rt6i_idev);
998
999 rt->rt6i_gateway = ort->rt6i_gateway;
1000 rt->rt6i_flags = ort->rt6i_flags;
1001 rt6_clean_expires(rt);
1002 rt->rt6i_metric = 0;
1003
1004 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1005 #ifdef CONFIG_IPV6_SUBTREES
1006 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1007 #endif
1008
1009 dst_free(new);
1010 }
1011
1012 dst_release(dst_orig);
1013 return new ? new : ERR_PTR(-ENOMEM);
1014 }
1015
1016 /*
1017 * Destination cache support functions
1018 */
1019
1020 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1021 {
1022 struct rt6_info *rt;
1023
1024 rt = (struct rt6_info *) dst;
1025
1026 /* All IPV6 dsts are created with ->obsolete set to the value
1027 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1028 * into this function always.
1029 */
1030 if (rt->rt6i_genid != rt_genid(dev_net(rt->dst.dev)))
1031 return NULL;
1032
1033 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie)) {
1034 if (rt->rt6i_peer_genid != rt6_peer_genid()) {
1035 if (!rt6_has_peer(rt))
1036 rt6_bind_peer(rt, 0);
1037 rt->rt6i_peer_genid = rt6_peer_genid();
1038 }
1039 return dst;
1040 }
1041 return NULL;
1042 }
1043
1044 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1045 {
1046 struct rt6_info *rt = (struct rt6_info *) dst;
1047
1048 if (rt) {
1049 if (rt->rt6i_flags & RTF_CACHE) {
1050 if (rt6_check_expired(rt)) {
1051 ip6_del_rt(rt);
1052 dst = NULL;
1053 }
1054 } else {
1055 dst_release(dst);
1056 dst = NULL;
1057 }
1058 }
1059 return dst;
1060 }
1061
1062 static void ip6_link_failure(struct sk_buff *skb)
1063 {
1064 struct rt6_info *rt;
1065
1066 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1067
1068 rt = (struct rt6_info *) skb_dst(skb);
1069 if (rt) {
1070 if (rt->rt6i_flags & RTF_CACHE)
1071 rt6_update_expires(rt, 0);
1072 else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
1073 rt->rt6i_node->fn_sernum = -1;
1074 }
1075 }
1076
1077 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1078 struct sk_buff *skb, u32 mtu)
1079 {
1080 struct rt6_info *rt6 = (struct rt6_info*)dst;
1081
1082 dst_confirm(dst);
1083 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
1084 struct net *net = dev_net(dst->dev);
1085
1086 rt6->rt6i_flags |= RTF_MODIFIED;
1087 if (mtu < IPV6_MIN_MTU) {
1088 u32 features = dst_metric(dst, RTAX_FEATURES);
1089 mtu = IPV6_MIN_MTU;
1090 features |= RTAX_FEATURE_ALLFRAG;
1091 dst_metric_set(dst, RTAX_FEATURES, features);
1092 }
1093 dst_metric_set(dst, RTAX_MTU, mtu);
1094 rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);
1095 }
1096 }
1097
1098 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1099 int oif, u32 mark)
1100 {
1101 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1102 struct dst_entry *dst;
1103 struct flowi6 fl6;
1104
1105 memset(&fl6, 0, sizeof(fl6));
1106 fl6.flowi6_oif = oif;
1107 fl6.flowi6_mark = mark;
1108 fl6.flowi6_flags = 0;
1109 fl6.daddr = iph->daddr;
1110 fl6.saddr = iph->saddr;
1111 fl6.flowlabel = (*(__be32 *) iph) & IPV6_FLOWINFO_MASK;
1112
1113 dst = ip6_route_output(net, NULL, &fl6);
1114 if (!dst->error)
1115 ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));
1116 dst_release(dst);
1117 }
1118 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1119
1120 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1121 {
1122 ip6_update_pmtu(skb, sock_net(sk), mtu,
1123 sk->sk_bound_dev_if, sk->sk_mark);
1124 }
1125 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1126
1127 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1128 {
1129 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1130 struct dst_entry *dst;
1131 struct flowi6 fl6;
1132
1133 memset(&fl6, 0, sizeof(fl6));
1134 fl6.flowi6_oif = oif;
1135 fl6.flowi6_mark = mark;
1136 fl6.flowi6_flags = 0;
1137 fl6.daddr = iph->daddr;
1138 fl6.saddr = iph->saddr;
1139 fl6.flowlabel = (*(__be32 *) iph) & IPV6_FLOWINFO_MASK;
1140
1141 dst = ip6_route_output(net, NULL, &fl6);
1142 if (!dst->error)
1143 rt6_do_redirect(dst, NULL, skb);
1144 dst_release(dst);
1145 }
1146 EXPORT_SYMBOL_GPL(ip6_redirect);
1147
1148 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1149 {
1150 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1151 }
1152 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1153
1154 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1155 {
1156 struct net_device *dev = dst->dev;
1157 unsigned int mtu = dst_mtu(dst);
1158 struct net *net = dev_net(dev);
1159
1160 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1161
1162 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1163 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1164
1165 /*
1166 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1167 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1168 * IPV6_MAXPLEN is also valid and means: "any MSS,
1169 * rely only on pmtu discovery"
1170 */
1171 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1172 mtu = IPV6_MAXPLEN;
1173 return mtu;
1174 }
1175
1176 static unsigned int ip6_mtu(const struct dst_entry *dst)
1177 {
1178 struct inet6_dev *idev;
1179 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
1180
1181 if (mtu)
1182 return mtu;
1183
1184 mtu = IPV6_MIN_MTU;
1185
1186 rcu_read_lock();
1187 idev = __in6_dev_get(dst->dev);
1188 if (idev)
1189 mtu = idev->cnf.mtu6;
1190 rcu_read_unlock();
1191
1192 return mtu;
1193 }
1194
1195 static struct dst_entry *icmp6_dst_gc_list;
1196 static DEFINE_SPINLOCK(icmp6_dst_lock);
1197
1198 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1199 struct neighbour *neigh,
1200 struct flowi6 *fl6)
1201 {
1202 struct dst_entry *dst;
1203 struct rt6_info *rt;
1204 struct inet6_dev *idev = in6_dev_get(dev);
1205 struct net *net = dev_net(dev);
1206
1207 if (unlikely(!idev))
1208 return ERR_PTR(-ENODEV);
1209
1210 rt = ip6_dst_alloc(net, dev, 0, NULL);
1211 if (unlikely(!rt)) {
1212 in6_dev_put(idev);
1213 dst = ERR_PTR(-ENOMEM);
1214 goto out;
1215 }
1216
1217 if (neigh)
1218 neigh_hold(neigh);
1219 else {
1220 neigh = ip6_neigh_lookup(&rt->dst, NULL, &fl6->daddr);
1221 if (IS_ERR(neigh)) {
1222 in6_dev_put(idev);
1223 dst_free(&rt->dst);
1224 return ERR_CAST(neigh);
1225 }
1226 }
1227
1228 rt->dst.flags |= DST_HOST;
1229 rt->dst.output = ip6_output;
1230 rt->n = neigh;
1231 atomic_set(&rt->dst.__refcnt, 1);
1232 rt->rt6i_dst.addr = fl6->daddr;
1233 rt->rt6i_dst.plen = 128;
1234 rt->rt6i_idev = idev;
1235 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 255);
1236
1237 spin_lock_bh(&icmp6_dst_lock);
1238 rt->dst.next = icmp6_dst_gc_list;
1239 icmp6_dst_gc_list = &rt->dst;
1240 spin_unlock_bh(&icmp6_dst_lock);
1241
1242 fib6_force_start_gc(net);
1243
1244 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1245
1246 out:
1247 return dst;
1248 }
1249
1250 int icmp6_dst_gc(void)
1251 {
1252 struct dst_entry *dst, **pprev;
1253 int more = 0;
1254
1255 spin_lock_bh(&icmp6_dst_lock);
1256 pprev = &icmp6_dst_gc_list;
1257
1258 while ((dst = *pprev) != NULL) {
1259 if (!atomic_read(&dst->__refcnt)) {
1260 *pprev = dst->next;
1261 dst_free(dst);
1262 } else {
1263 pprev = &dst->next;
1264 ++more;
1265 }
1266 }
1267
1268 spin_unlock_bh(&icmp6_dst_lock);
1269
1270 return more;
1271 }
1272
1273 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1274 void *arg)
1275 {
1276 struct dst_entry *dst, **pprev;
1277
1278 spin_lock_bh(&icmp6_dst_lock);
1279 pprev = &icmp6_dst_gc_list;
1280 while ((dst = *pprev) != NULL) {
1281 struct rt6_info *rt = (struct rt6_info *) dst;
1282 if (func(rt, arg)) {
1283 *pprev = dst->next;
1284 dst_free(dst);
1285 } else {
1286 pprev = &dst->next;
1287 }
1288 }
1289 spin_unlock_bh(&icmp6_dst_lock);
1290 }
1291
1292 static int ip6_dst_gc(struct dst_ops *ops)
1293 {
1294 unsigned long now = jiffies;
1295 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1296 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1297 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1298 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1299 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1300 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1301 int entries;
1302
1303 entries = dst_entries_get_fast(ops);
1304 if (time_after(rt_last_gc + rt_min_interval, now) &&
1305 entries <= rt_max_size)
1306 goto out;
1307
1308 net->ipv6.ip6_rt_gc_expire++;
1309 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1310 net->ipv6.ip6_rt_last_gc = now;
1311 entries = dst_entries_get_slow(ops);
1312 if (entries < ops->gc_thresh)
1313 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1314 out:
1315 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1316 return entries > rt_max_size;
1317 }
1318
1319 /* Clean host part of a prefix. Not necessary in radix tree,
1320 but results in cleaner routing tables.
1321
1322 Remove it only when all the things will work!
1323 */
1324
1325 int ip6_dst_hoplimit(struct dst_entry *dst)
1326 {
1327 int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
1328 if (hoplimit == 0) {
1329 struct net_device *dev = dst->dev;
1330 struct inet6_dev *idev;
1331
1332 rcu_read_lock();
1333 idev = __in6_dev_get(dev);
1334 if (idev)
1335 hoplimit = idev->cnf.hop_limit;
1336 else
1337 hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1338 rcu_read_unlock();
1339 }
1340 return hoplimit;
1341 }
1342 EXPORT_SYMBOL(ip6_dst_hoplimit);
1343
1344 /*
1345 *
1346 */
1347
1348 int ip6_route_add(struct fib6_config *cfg)
1349 {
1350 int err;
1351 struct net *net = cfg->fc_nlinfo.nl_net;
1352 struct rt6_info *rt = NULL;
1353 struct net_device *dev = NULL;
1354 struct inet6_dev *idev = NULL;
1355 struct fib6_table *table;
1356 int addr_type;
1357
1358 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1359 return -EINVAL;
1360 #ifndef CONFIG_IPV6_SUBTREES
1361 if (cfg->fc_src_len)
1362 return -EINVAL;
1363 #endif
1364 if (cfg->fc_ifindex) {
1365 err = -ENODEV;
1366 dev = dev_get_by_index(net, cfg->fc_ifindex);
1367 if (!dev)
1368 goto out;
1369 idev = in6_dev_get(dev);
1370 if (!idev)
1371 goto out;
1372 }
1373
1374 if (cfg->fc_metric == 0)
1375 cfg->fc_metric = IP6_RT_PRIO_USER;
1376
1377 err = -ENOBUFS;
1378 if (cfg->fc_nlinfo.nlh &&
1379 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1380 table = fib6_get_table(net, cfg->fc_table);
1381 if (!table) {
1382 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1383 table = fib6_new_table(net, cfg->fc_table);
1384 }
1385 } else {
1386 table = fib6_new_table(net, cfg->fc_table);
1387 }
1388
1389 if (!table)
1390 goto out;
1391
1392 rt = ip6_dst_alloc(net, NULL, DST_NOCOUNT, table);
1393
1394 if (!rt) {
1395 err = -ENOMEM;
1396 goto out;
1397 }
1398
1399 if (cfg->fc_flags & RTF_EXPIRES)
1400 rt6_set_expires(rt, jiffies +
1401 clock_t_to_jiffies(cfg->fc_expires));
1402 else
1403 rt6_clean_expires(rt);
1404
1405 if (cfg->fc_protocol == RTPROT_UNSPEC)
1406 cfg->fc_protocol = RTPROT_BOOT;
1407 rt->rt6i_protocol = cfg->fc_protocol;
1408
1409 addr_type = ipv6_addr_type(&cfg->fc_dst);
1410
1411 if (addr_type & IPV6_ADDR_MULTICAST)
1412 rt->dst.input = ip6_mc_input;
1413 else if (cfg->fc_flags & RTF_LOCAL)
1414 rt->dst.input = ip6_input;
1415 else
1416 rt->dst.input = ip6_forward;
1417
1418 rt->dst.output = ip6_output;
1419
1420 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1421 rt->rt6i_dst.plen = cfg->fc_dst_len;
1422 if (rt->rt6i_dst.plen == 128)
1423 rt->dst.flags |= DST_HOST;
1424
1425 if (!(rt->dst.flags & DST_HOST) && cfg->fc_mx) {
1426 u32 *metrics = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1427 if (!metrics) {
1428 err = -ENOMEM;
1429 goto out;
1430 }
1431 dst_init_metrics(&rt->dst, metrics, 0);
1432 }
1433 #ifdef CONFIG_IPV6_SUBTREES
1434 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1435 rt->rt6i_src.plen = cfg->fc_src_len;
1436 #endif
1437
1438 rt->rt6i_metric = cfg->fc_metric;
1439
1440 /* We cannot add true routes via loopback here,
1441 they would result in kernel looping; promote them to reject routes
1442 */
1443 if ((cfg->fc_flags & RTF_REJECT) ||
1444 (dev && (dev->flags & IFF_LOOPBACK) &&
1445 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1446 !(cfg->fc_flags & RTF_LOCAL))) {
1447 /* hold loopback dev/idev if we haven't done so. */
1448 if (dev != net->loopback_dev) {
1449 if (dev) {
1450 dev_put(dev);
1451 in6_dev_put(idev);
1452 }
1453 dev = net->loopback_dev;
1454 dev_hold(dev);
1455 idev = in6_dev_get(dev);
1456 if (!idev) {
1457 err = -ENODEV;
1458 goto out;
1459 }
1460 }
1461 rt->dst.output = ip6_pkt_discard_out;
1462 rt->dst.input = ip6_pkt_discard;
1463 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1464 switch (cfg->fc_type) {
1465 case RTN_BLACKHOLE:
1466 rt->dst.error = -EINVAL;
1467 break;
1468 case RTN_PROHIBIT:
1469 rt->dst.error = -EACCES;
1470 break;
1471 case RTN_THROW:
1472 rt->dst.error = -EAGAIN;
1473 break;
1474 default:
1475 rt->dst.error = -ENETUNREACH;
1476 break;
1477 }
1478 goto install_route;
1479 }
1480
1481 if (cfg->fc_flags & RTF_GATEWAY) {
1482 const struct in6_addr *gw_addr;
1483 int gwa_type;
1484
1485 gw_addr = &cfg->fc_gateway;
1486 rt->rt6i_gateway = *gw_addr;
1487 gwa_type = ipv6_addr_type(gw_addr);
1488
1489 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1490 struct rt6_info *grt;
1491
1492 /* IPv6 strictly inhibits using not link-local
1493 addresses as nexthop address.
1494 Otherwise, router will not able to send redirects.
1495 It is very good, but in some (rare!) circumstances
1496 (SIT, PtP, NBMA NOARP links) it is handy to allow
1497 some exceptions. --ANK
1498 */
1499 err = -EINVAL;
1500 if (!(gwa_type & IPV6_ADDR_UNICAST))
1501 goto out;
1502
1503 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1504
1505 err = -EHOSTUNREACH;
1506 if (!grt)
1507 goto out;
1508 if (dev) {
1509 if (dev != grt->dst.dev) {
1510 dst_release(&grt->dst);
1511 goto out;
1512 }
1513 } else {
1514 dev = grt->dst.dev;
1515 idev = grt->rt6i_idev;
1516 dev_hold(dev);
1517 in6_dev_hold(grt->rt6i_idev);
1518 }
1519 if (!(grt->rt6i_flags & RTF_GATEWAY))
1520 err = 0;
1521 dst_release(&grt->dst);
1522
1523 if (err)
1524 goto out;
1525 }
1526 err = -EINVAL;
1527 if (!dev || (dev->flags & IFF_LOOPBACK))
1528 goto out;
1529 }
1530
1531 err = -ENODEV;
1532 if (!dev)
1533 goto out;
1534
1535 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1536 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1537 err = -EINVAL;
1538 goto out;
1539 }
1540 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1541 rt->rt6i_prefsrc.plen = 128;
1542 } else
1543 rt->rt6i_prefsrc.plen = 0;
1544
1545 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1546 err = rt6_bind_neighbour(rt, dev);
1547 if (err)
1548 goto out;
1549 }
1550
1551 rt->rt6i_flags = cfg->fc_flags;
1552
1553 install_route:
1554 if (cfg->fc_mx) {
1555 struct nlattr *nla;
1556 int remaining;
1557
1558 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1559 int type = nla_type(nla);
1560
1561 if (type) {
1562 if (type > RTAX_MAX) {
1563 err = -EINVAL;
1564 goto out;
1565 }
1566
1567 dst_metric_set(&rt->dst, type, nla_get_u32(nla));
1568 }
1569 }
1570 }
1571
1572 rt->dst.dev = dev;
1573 rt->rt6i_idev = idev;
1574 rt->rt6i_table = table;
1575
1576 cfg->fc_nlinfo.nl_net = dev_net(dev);
1577
1578 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1579
1580 out:
1581 if (dev)
1582 dev_put(dev);
1583 if (idev)
1584 in6_dev_put(idev);
1585 if (rt)
1586 dst_free(&rt->dst);
1587 return err;
1588 }
1589
1590 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1591 {
1592 int err;
1593 struct fib6_table *table;
1594 struct net *net = dev_net(rt->dst.dev);
1595
1596 if (rt == net->ipv6.ip6_null_entry) {
1597 err = -ENOENT;
1598 goto out;
1599 }
1600
1601 table = rt->rt6i_table;
1602 write_lock_bh(&table->tb6_lock);
1603 err = fib6_del(rt, info);
1604 write_unlock_bh(&table->tb6_lock);
1605
1606 out:
1607 dst_release(&rt->dst);
1608 return err;
1609 }
1610
1611 int ip6_del_rt(struct rt6_info *rt)
1612 {
1613 struct nl_info info = {
1614 .nl_net = dev_net(rt->dst.dev),
1615 };
1616 return __ip6_del_rt(rt, &info);
1617 }
1618
1619 static int ip6_route_del(struct fib6_config *cfg)
1620 {
1621 struct fib6_table *table;
1622 struct fib6_node *fn;
1623 struct rt6_info *rt;
1624 int err = -ESRCH;
1625
1626 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1627 if (!table)
1628 return err;
1629
1630 read_lock_bh(&table->tb6_lock);
1631
1632 fn = fib6_locate(&table->tb6_root,
1633 &cfg->fc_dst, cfg->fc_dst_len,
1634 &cfg->fc_src, cfg->fc_src_len);
1635
1636 if (fn) {
1637 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1638 if (cfg->fc_ifindex &&
1639 (!rt->dst.dev ||
1640 rt->dst.dev->ifindex != cfg->fc_ifindex))
1641 continue;
1642 if (cfg->fc_flags & RTF_GATEWAY &&
1643 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1644 continue;
1645 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1646 continue;
1647 dst_hold(&rt->dst);
1648 read_unlock_bh(&table->tb6_lock);
1649
1650 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1651 }
1652 }
1653 read_unlock_bh(&table->tb6_lock);
1654
1655 return err;
1656 }
1657
1658 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
1659 {
1660 struct net *net = dev_net(skb->dev);
1661 struct netevent_redirect netevent;
1662 struct rt6_info *rt, *nrt = NULL;
1663 const struct in6_addr *target;
1664 struct ndisc_options ndopts;
1665 const struct in6_addr *dest;
1666 struct neighbour *old_neigh;
1667 struct inet6_dev *in6_dev;
1668 struct neighbour *neigh;
1669 struct icmp6hdr *icmph;
1670 int optlen, on_link;
1671 u8 *lladdr;
1672
1673 optlen = skb->tail - skb->transport_header;
1674 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1675
1676 if (optlen < 0) {
1677 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
1678 return;
1679 }
1680
1681 icmph = icmp6_hdr(skb);
1682 target = (const struct in6_addr *) (icmph + 1);
1683 dest = target + 1;
1684
1685 if (ipv6_addr_is_multicast(dest)) {
1686 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
1687 return;
1688 }
1689
1690 on_link = 0;
1691 if (ipv6_addr_equal(dest, target)) {
1692 on_link = 1;
1693 } else if (ipv6_addr_type(target) !=
1694 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1695 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
1696 return;
1697 }
1698
1699 in6_dev = __in6_dev_get(skb->dev);
1700 if (!in6_dev)
1701 return;
1702 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
1703 return;
1704
1705 /* RFC2461 8.1:
1706 * The IP source address of the Redirect MUST be the same as the current
1707 * first-hop router for the specified ICMP Destination Address.
1708 */
1709
1710 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1711 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
1712 return;
1713 }
1714
1715 lladdr = NULL;
1716 if (ndopts.nd_opts_tgt_lladdr) {
1717 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1718 skb->dev);
1719 if (!lladdr) {
1720 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
1721 return;
1722 }
1723 }
1724
1725 rt = (struct rt6_info *) dst;
1726 if (rt == net->ipv6.ip6_null_entry) {
1727 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
1728 return;
1729 }
1730
1731 /* Redirect received -> path was valid.
1732 * Look, redirects are sent only in response to data packets,
1733 * so that this nexthop apparently is reachable. --ANK
1734 */
1735 dst_confirm(&rt->dst);
1736
1737 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1738 if (!neigh)
1739 return;
1740
1741 /* Duplicate redirect: silently ignore. */
1742 old_neigh = rt->n;
1743 if (neigh == old_neigh)
1744 goto out;
1745
1746 /*
1747 * We have finally decided to accept it.
1748 */
1749
1750 neigh_update(neigh, lladdr, NUD_STALE,
1751 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1752 NEIGH_UPDATE_F_OVERRIDE|
1753 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1754 NEIGH_UPDATE_F_ISROUTER))
1755 );
1756
1757 nrt = ip6_rt_copy(rt, dest);
1758 if (!nrt)
1759 goto out;
1760
1761 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1762 if (on_link)
1763 nrt->rt6i_flags &= ~RTF_GATEWAY;
1764
1765 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
1766 nrt->n = neigh_clone(neigh);
1767
1768 if (ip6_ins_rt(nrt))
1769 goto out;
1770
1771 netevent.old = &rt->dst;
1772 netevent.old_neigh = old_neigh;
1773 netevent.new = &nrt->dst;
1774 netevent.new_neigh = neigh;
1775 netevent.daddr = dest;
1776 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1777
1778 if (rt->rt6i_flags & RTF_CACHE) {
1779 rt = (struct rt6_info *) dst_clone(&rt->dst);
1780 ip6_del_rt(rt);
1781 }
1782
1783 out:
1784 neigh_release(neigh);
1785 }
1786
1787 /*
1788 * Misc support functions
1789 */
1790
1791 static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,
1792 const struct in6_addr *dest)
1793 {
1794 struct net *net = dev_net(ort->dst.dev);
1795 struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,
1796 ort->rt6i_table);
1797
1798 if (rt) {
1799 rt->dst.input = ort->dst.input;
1800 rt->dst.output = ort->dst.output;
1801 rt->dst.flags |= DST_HOST;
1802
1803 rt->rt6i_dst.addr = *dest;
1804 rt->rt6i_dst.plen = 128;
1805 dst_copy_metrics(&rt->dst, &ort->dst);
1806 rt->dst.error = ort->dst.error;
1807 rt->rt6i_idev = ort->rt6i_idev;
1808 if (rt->rt6i_idev)
1809 in6_dev_hold(rt->rt6i_idev);
1810 rt->dst.lastuse = jiffies;
1811
1812 rt->rt6i_gateway = ort->rt6i_gateway;
1813 rt->rt6i_flags = ort->rt6i_flags;
1814 if ((ort->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) ==
1815 (RTF_DEFAULT | RTF_ADDRCONF))
1816 rt6_set_from(rt, ort);
1817 else
1818 rt6_clean_expires(rt);
1819 rt->rt6i_metric = 0;
1820
1821 #ifdef CONFIG_IPV6_SUBTREES
1822 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1823 #endif
1824 memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));
1825 rt->rt6i_table = ort->rt6i_table;
1826 }
1827 return rt;
1828 }
1829
1830 #ifdef CONFIG_IPV6_ROUTE_INFO
1831 static struct rt6_info *rt6_get_route_info(struct net *net,
1832 const struct in6_addr *prefix, int prefixlen,
1833 const struct in6_addr *gwaddr, int ifindex)
1834 {
1835 struct fib6_node *fn;
1836 struct rt6_info *rt = NULL;
1837 struct fib6_table *table;
1838
1839 table = fib6_get_table(net, RT6_TABLE_INFO);
1840 if (!table)
1841 return NULL;
1842
1843 read_lock_bh(&table->tb6_lock);
1844 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1845 if (!fn)
1846 goto out;
1847
1848 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1849 if (rt->dst.dev->ifindex != ifindex)
1850 continue;
1851 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1852 continue;
1853 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1854 continue;
1855 dst_hold(&rt->dst);
1856 break;
1857 }
1858 out:
1859 read_unlock_bh(&table->tb6_lock);
1860 return rt;
1861 }
1862
1863 static struct rt6_info *rt6_add_route_info(struct net *net,
1864 const struct in6_addr *prefix, int prefixlen,
1865 const struct in6_addr *gwaddr, int ifindex,
1866 unsigned int pref)
1867 {
1868 struct fib6_config cfg = {
1869 .fc_table = RT6_TABLE_INFO,
1870 .fc_metric = IP6_RT_PRIO_USER,
1871 .fc_ifindex = ifindex,
1872 .fc_dst_len = prefixlen,
1873 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1874 RTF_UP | RTF_PREF(pref),
1875 .fc_nlinfo.portid = 0,
1876 .fc_nlinfo.nlh = NULL,
1877 .fc_nlinfo.nl_net = net,
1878 };
1879
1880 cfg.fc_dst = *prefix;
1881 cfg.fc_gateway = *gwaddr;
1882
1883 /* We should treat it as a default route if prefix length is 0. */
1884 if (!prefixlen)
1885 cfg.fc_flags |= RTF_DEFAULT;
1886
1887 ip6_route_add(&cfg);
1888
1889 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1890 }
1891 #endif
1892
1893 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
1894 {
1895 struct rt6_info *rt;
1896 struct fib6_table *table;
1897
1898 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1899 if (!table)
1900 return NULL;
1901
1902 read_lock_bh(&table->tb6_lock);
1903 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1904 if (dev == rt->dst.dev &&
1905 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1906 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1907 break;
1908 }
1909 if (rt)
1910 dst_hold(&rt->dst);
1911 read_unlock_bh(&table->tb6_lock);
1912 return rt;
1913 }
1914
1915 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
1916 struct net_device *dev,
1917 unsigned int pref)
1918 {
1919 struct fib6_config cfg = {
1920 .fc_table = RT6_TABLE_DFLT,
1921 .fc_metric = IP6_RT_PRIO_USER,
1922 .fc_ifindex = dev->ifindex,
1923 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1924 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1925 .fc_nlinfo.portid = 0,
1926 .fc_nlinfo.nlh = NULL,
1927 .fc_nlinfo.nl_net = dev_net(dev),
1928 };
1929
1930 cfg.fc_gateway = *gwaddr;
1931
1932 ip6_route_add(&cfg);
1933
1934 return rt6_get_dflt_router(gwaddr, dev);
1935 }
1936
1937 void rt6_purge_dflt_routers(struct net *net)
1938 {
1939 struct rt6_info *rt;
1940 struct fib6_table *table;
1941
1942 /* NOTE: Keep consistent with rt6_get_dflt_router */
1943 table = fib6_get_table(net, RT6_TABLE_DFLT);
1944 if (!table)
1945 return;
1946
1947 restart:
1948 read_lock_bh(&table->tb6_lock);
1949 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1950 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1951 dst_hold(&rt->dst);
1952 read_unlock_bh(&table->tb6_lock);
1953 ip6_del_rt(rt);
1954 goto restart;
1955 }
1956 }
1957 read_unlock_bh(&table->tb6_lock);
1958 }
1959
1960 static void rtmsg_to_fib6_config(struct net *net,
1961 struct in6_rtmsg *rtmsg,
1962 struct fib6_config *cfg)
1963 {
1964 memset(cfg, 0, sizeof(*cfg));
1965
1966 cfg->fc_table = RT6_TABLE_MAIN;
1967 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1968 cfg->fc_metric = rtmsg->rtmsg_metric;
1969 cfg->fc_expires = rtmsg->rtmsg_info;
1970 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1971 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1972 cfg->fc_flags = rtmsg->rtmsg_flags;
1973
1974 cfg->fc_nlinfo.nl_net = net;
1975
1976 cfg->fc_dst = rtmsg->rtmsg_dst;
1977 cfg->fc_src = rtmsg->rtmsg_src;
1978 cfg->fc_gateway = rtmsg->rtmsg_gateway;
1979 }
1980
1981 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1982 {
1983 struct fib6_config cfg;
1984 struct in6_rtmsg rtmsg;
1985 int err;
1986
1987 switch(cmd) {
1988 case SIOCADDRT: /* Add a route */
1989 case SIOCDELRT: /* Delete a route */
1990 if (!capable(CAP_NET_ADMIN))
1991 return -EPERM;
1992 err = copy_from_user(&rtmsg, arg,
1993 sizeof(struct in6_rtmsg));
1994 if (err)
1995 return -EFAULT;
1996
1997 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
1998
1999 rtnl_lock();
2000 switch (cmd) {
2001 case SIOCADDRT:
2002 err = ip6_route_add(&cfg);
2003 break;
2004 case SIOCDELRT:
2005 err = ip6_route_del(&cfg);
2006 break;
2007 default:
2008 err = -EINVAL;
2009 }
2010 rtnl_unlock();
2011
2012 return err;
2013 }
2014
2015 return -EINVAL;
2016 }
2017
2018 /*
2019 * Drop the packet on the floor
2020 */
2021
2022 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2023 {
2024 int type;
2025 struct dst_entry *dst = skb_dst(skb);
2026 switch (ipstats_mib_noroutes) {
2027 case IPSTATS_MIB_INNOROUTES:
2028 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2029 if (type == IPV6_ADDR_ANY) {
2030 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2031 IPSTATS_MIB_INADDRERRORS);
2032 break;
2033 }
2034 /* FALLTHROUGH */
2035 case IPSTATS_MIB_OUTNOROUTES:
2036 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2037 ipstats_mib_noroutes);
2038 break;
2039 }
2040 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2041 kfree_skb(skb);
2042 return 0;
2043 }
2044
2045 static int ip6_pkt_discard(struct sk_buff *skb)
2046 {
2047 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2048 }
2049
2050 static int ip6_pkt_discard_out(struct sk_buff *skb)
2051 {
2052 skb->dev = skb_dst(skb)->dev;
2053 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2054 }
2055
2056 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2057
2058 static int ip6_pkt_prohibit(struct sk_buff *skb)
2059 {
2060 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2061 }
2062
2063 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
2064 {
2065 skb->dev = skb_dst(skb)->dev;
2066 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2067 }
2068
2069 #endif
2070
2071 /*
2072 * Allocate a dst for local (unicast / anycast) address.
2073 */
2074
2075 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2076 const struct in6_addr *addr,
2077 bool anycast)
2078 {
2079 struct net *net = dev_net(idev->dev);
2080 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev, 0, NULL);
2081 int err;
2082
2083 if (!rt) {
2084 net_warn_ratelimited("Maximum number of routes reached, consider increasing route/max_size\n");
2085 return ERR_PTR(-ENOMEM);
2086 }
2087
2088 in6_dev_hold(idev);
2089
2090 rt->dst.flags |= DST_HOST;
2091 rt->dst.input = ip6_input;
2092 rt->dst.output = ip6_output;
2093 rt->rt6i_idev = idev;
2094
2095 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2096 if (anycast)
2097 rt->rt6i_flags |= RTF_ANYCAST;
2098 else
2099 rt->rt6i_flags |= RTF_LOCAL;
2100 err = rt6_bind_neighbour(rt, rt->dst.dev);
2101 if (err) {
2102 dst_free(&rt->dst);
2103 return ERR_PTR(err);
2104 }
2105
2106 rt->rt6i_dst.addr = *addr;
2107 rt->rt6i_dst.plen = 128;
2108 rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
2109
2110 atomic_set(&rt->dst.__refcnt, 1);
2111
2112 return rt;
2113 }
2114
2115 int ip6_route_get_saddr(struct net *net,
2116 struct rt6_info *rt,
2117 const struct in6_addr *daddr,
2118 unsigned int prefs,
2119 struct in6_addr *saddr)
2120 {
2121 struct inet6_dev *idev = ip6_dst_idev((struct dst_entry*)rt);
2122 int err = 0;
2123 if (rt->rt6i_prefsrc.plen)
2124 *saddr = rt->rt6i_prefsrc.addr;
2125 else
2126 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2127 daddr, prefs, saddr);
2128 return err;
2129 }
2130
2131 /* remove deleted ip from prefsrc entries */
2132 struct arg_dev_net_ip {
2133 struct net_device *dev;
2134 struct net *net;
2135 struct in6_addr *addr;
2136 };
2137
2138 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2139 {
2140 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2141 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2142 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2143
2144 if (((void *)rt->dst.dev == dev || !dev) &&
2145 rt != net->ipv6.ip6_null_entry &&
2146 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2147 /* remove prefsrc entry */
2148 rt->rt6i_prefsrc.plen = 0;
2149 }
2150 return 0;
2151 }
2152
2153 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2154 {
2155 struct net *net = dev_net(ifp->idev->dev);
2156 struct arg_dev_net_ip adni = {
2157 .dev = ifp->idev->dev,
2158 .net = net,
2159 .addr = &ifp->addr,
2160 };
2161 fib6_clean_all(net, fib6_remove_prefsrc, 0, &adni);
2162 }
2163
2164 struct arg_dev_net {
2165 struct net_device *dev;
2166 struct net *net;
2167 };
2168
2169 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2170 {
2171 const struct arg_dev_net *adn = arg;
2172 const struct net_device *dev = adn->dev;
2173
2174 if ((rt->dst.dev == dev || !dev) &&
2175 rt != adn->net->ipv6.ip6_null_entry)
2176 return -1;
2177
2178 return 0;
2179 }
2180
2181 void rt6_ifdown(struct net *net, struct net_device *dev)
2182 {
2183 struct arg_dev_net adn = {
2184 .dev = dev,
2185 .net = net,
2186 };
2187
2188 fib6_clean_all(net, fib6_ifdown, 0, &adn);
2189 icmp6_clean_all(fib6_ifdown, &adn);
2190 }
2191
2192 struct rt6_mtu_change_arg {
2193 struct net_device *dev;
2194 unsigned int mtu;
2195 };
2196
2197 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2198 {
2199 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2200 struct inet6_dev *idev;
2201
2202 /* In IPv6 pmtu discovery is not optional,
2203 so that RTAX_MTU lock cannot disable it.
2204 We still use this lock to block changes
2205 caused by addrconf/ndisc.
2206 */
2207
2208 idev = __in6_dev_get(arg->dev);
2209 if (!idev)
2210 return 0;
2211
2212 /* For administrative MTU increase, there is no way to discover
2213 IPv6 PMTU increase, so PMTU increase should be updated here.
2214 Since RFC 1981 doesn't include administrative MTU increase
2215 update PMTU increase is a MUST. (i.e. jumbo frame)
2216 */
2217 /*
2218 If new MTU is less than route PMTU, this new MTU will be the
2219 lowest MTU in the path, update the route PMTU to reflect PMTU
2220 decreases; if new MTU is greater than route PMTU, and the
2221 old MTU is the lowest MTU in the path, update the route PMTU
2222 to reflect the increase. In this case if the other nodes' MTU
2223 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2224 PMTU discouvery.
2225 */
2226 if (rt->dst.dev == arg->dev &&
2227 !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2228 (dst_mtu(&rt->dst) >= arg->mtu ||
2229 (dst_mtu(&rt->dst) < arg->mtu &&
2230 dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2231 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2232 }
2233 return 0;
2234 }
2235
2236 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2237 {
2238 struct rt6_mtu_change_arg arg = {
2239 .dev = dev,
2240 .mtu = mtu,
2241 };
2242
2243 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
2244 }
2245
2246 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2247 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2248 [RTA_OIF] = { .type = NLA_U32 },
2249 [RTA_IIF] = { .type = NLA_U32 },
2250 [RTA_PRIORITY] = { .type = NLA_U32 },
2251 [RTA_METRICS] = { .type = NLA_NESTED },
2252 };
2253
2254 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2255 struct fib6_config *cfg)
2256 {
2257 struct rtmsg *rtm;
2258 struct nlattr *tb[RTA_MAX+1];
2259 int err;
2260
2261 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2262 if (err < 0)
2263 goto errout;
2264
2265 err = -EINVAL;
2266 rtm = nlmsg_data(nlh);
2267 memset(cfg, 0, sizeof(*cfg));
2268
2269 cfg->fc_table = rtm->rtm_table;
2270 cfg->fc_dst_len = rtm->rtm_dst_len;
2271 cfg->fc_src_len = rtm->rtm_src_len;
2272 cfg->fc_flags = RTF_UP;
2273 cfg->fc_protocol = rtm->rtm_protocol;
2274 cfg->fc_type = rtm->rtm_type;
2275
2276 if (rtm->rtm_type == RTN_UNREACHABLE ||
2277 rtm->rtm_type == RTN_BLACKHOLE ||
2278 rtm->rtm_type == RTN_PROHIBIT ||
2279 rtm->rtm_type == RTN_THROW)
2280 cfg->fc_flags |= RTF_REJECT;
2281
2282 if (rtm->rtm_type == RTN_LOCAL)
2283 cfg->fc_flags |= RTF_LOCAL;
2284
2285 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2286 cfg->fc_nlinfo.nlh = nlh;
2287 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2288
2289 if (tb[RTA_GATEWAY]) {
2290 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
2291 cfg->fc_flags |= RTF_GATEWAY;
2292 }
2293
2294 if (tb[RTA_DST]) {
2295 int plen = (rtm->rtm_dst_len + 7) >> 3;
2296
2297 if (nla_len(tb[RTA_DST]) < plen)
2298 goto errout;
2299
2300 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2301 }
2302
2303 if (tb[RTA_SRC]) {
2304 int plen = (rtm->rtm_src_len + 7) >> 3;
2305
2306 if (nla_len(tb[RTA_SRC]) < plen)
2307 goto errout;
2308
2309 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2310 }
2311
2312 if (tb[RTA_PREFSRC])
2313 nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);
2314
2315 if (tb[RTA_OIF])
2316 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2317
2318 if (tb[RTA_PRIORITY])
2319 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2320
2321 if (tb[RTA_METRICS]) {
2322 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2323 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2324 }
2325
2326 if (tb[RTA_TABLE])
2327 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2328
2329 err = 0;
2330 errout:
2331 return err;
2332 }
2333
2334 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2335 {
2336 struct fib6_config cfg;
2337 int err;
2338
2339 err = rtm_to_fib6_config(skb, nlh, &cfg);
2340 if (err < 0)
2341 return err;
2342
2343 return ip6_route_del(&cfg);
2344 }
2345
2346 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2347 {
2348 struct fib6_config cfg;
2349 int err;
2350
2351 err = rtm_to_fib6_config(skb, nlh, &cfg);
2352 if (err < 0)
2353 return err;
2354
2355 return ip6_route_add(&cfg);
2356 }
2357
2358 static inline size_t rt6_nlmsg_size(void)
2359 {
2360 return NLMSG_ALIGN(sizeof(struct rtmsg))
2361 + nla_total_size(16) /* RTA_SRC */
2362 + nla_total_size(16) /* RTA_DST */
2363 + nla_total_size(16) /* RTA_GATEWAY */
2364 + nla_total_size(16) /* RTA_PREFSRC */
2365 + nla_total_size(4) /* RTA_TABLE */
2366 + nla_total_size(4) /* RTA_IIF */
2367 + nla_total_size(4) /* RTA_OIF */
2368 + nla_total_size(4) /* RTA_PRIORITY */
2369 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2370 + nla_total_size(sizeof(struct rta_cacheinfo));
2371 }
2372
2373 static int rt6_fill_node(struct net *net,
2374 struct sk_buff *skb, struct rt6_info *rt,
2375 struct in6_addr *dst, struct in6_addr *src,
2376 int iif, int type, u32 portid, u32 seq,
2377 int prefix, int nowait, unsigned int flags)
2378 {
2379 struct rtmsg *rtm;
2380 struct nlmsghdr *nlh;
2381 long expires;
2382 u32 table;
2383 struct neighbour *n;
2384
2385 if (prefix) { /* user wants prefix routes only */
2386 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2387 /* success since this is not a prefix route */
2388 return 1;
2389 }
2390 }
2391
2392 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
2393 if (!nlh)
2394 return -EMSGSIZE;
2395
2396 rtm = nlmsg_data(nlh);
2397 rtm->rtm_family = AF_INET6;
2398 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2399 rtm->rtm_src_len = rt->rt6i_src.plen;
2400 rtm->rtm_tos = 0;
2401 if (rt->rt6i_table)
2402 table = rt->rt6i_table->tb6_id;
2403 else
2404 table = RT6_TABLE_UNSPEC;
2405 rtm->rtm_table = table;
2406 if (nla_put_u32(skb, RTA_TABLE, table))
2407 goto nla_put_failure;
2408 if (rt->rt6i_flags & RTF_REJECT) {
2409 switch (rt->dst.error) {
2410 case -EINVAL:
2411 rtm->rtm_type = RTN_BLACKHOLE;
2412 break;
2413 case -EACCES:
2414 rtm->rtm_type = RTN_PROHIBIT;
2415 break;
2416 case -EAGAIN:
2417 rtm->rtm_type = RTN_THROW;
2418 break;
2419 default:
2420 rtm->rtm_type = RTN_UNREACHABLE;
2421 break;
2422 }
2423 }
2424 else if (rt->rt6i_flags & RTF_LOCAL)
2425 rtm->rtm_type = RTN_LOCAL;
2426 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
2427 rtm->rtm_type = RTN_LOCAL;
2428 else
2429 rtm->rtm_type = RTN_UNICAST;
2430 rtm->rtm_flags = 0;
2431 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2432 rtm->rtm_protocol = rt->rt6i_protocol;
2433 if (rt->rt6i_flags & RTF_DYNAMIC)
2434 rtm->rtm_protocol = RTPROT_REDIRECT;
2435 else if (rt->rt6i_flags & RTF_ADDRCONF) {
2436 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
2437 rtm->rtm_protocol = RTPROT_RA;
2438 else
2439 rtm->rtm_protocol = RTPROT_KERNEL;
2440 }
2441
2442 if (rt->rt6i_flags & RTF_CACHE)
2443 rtm->rtm_flags |= RTM_F_CLONED;
2444
2445 if (dst) {
2446 if (nla_put(skb, RTA_DST, 16, dst))
2447 goto nla_put_failure;
2448 rtm->rtm_dst_len = 128;
2449 } else if (rtm->rtm_dst_len)
2450 if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))
2451 goto nla_put_failure;
2452 #ifdef CONFIG_IPV6_SUBTREES
2453 if (src) {
2454 if (nla_put(skb, RTA_SRC, 16, src))
2455 goto nla_put_failure;
2456 rtm->rtm_src_len = 128;
2457 } else if (rtm->rtm_src_len &&
2458 nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))
2459 goto nla_put_failure;
2460 #endif
2461 if (iif) {
2462 #ifdef CONFIG_IPV6_MROUTE
2463 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
2464 int err = ip6mr_get_route(net, skb, rtm, nowait);
2465 if (err <= 0) {
2466 if (!nowait) {
2467 if (err == 0)
2468 return 0;
2469 goto nla_put_failure;
2470 } else {
2471 if (err == -EMSGSIZE)
2472 goto nla_put_failure;
2473 }
2474 }
2475 } else
2476 #endif
2477 if (nla_put_u32(skb, RTA_IIF, iif))
2478 goto nla_put_failure;
2479 } else if (dst) {
2480 struct in6_addr saddr_buf;
2481 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
2482 nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2483 goto nla_put_failure;
2484 }
2485
2486 if (rt->rt6i_prefsrc.plen) {
2487 struct in6_addr saddr_buf;
2488 saddr_buf = rt->rt6i_prefsrc.addr;
2489 if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))
2490 goto nla_put_failure;
2491 }
2492
2493 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
2494 goto nla_put_failure;
2495
2496 n = rt->n;
2497 if (n) {
2498 if (nla_put(skb, RTA_GATEWAY, 16, &n->primary_key) < 0)
2499 goto nla_put_failure;
2500 }
2501
2502 if (rt->dst.dev &&
2503 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2504 goto nla_put_failure;
2505 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
2506 goto nla_put_failure;
2507
2508 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
2509
2510 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
2511 goto nla_put_failure;
2512
2513 return nlmsg_end(skb, nlh);
2514
2515 nla_put_failure:
2516 nlmsg_cancel(skb, nlh);
2517 return -EMSGSIZE;
2518 }
2519
2520 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2521 {
2522 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2523 int prefix;
2524
2525 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2526 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2527 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2528 } else
2529 prefix = 0;
2530
2531 return rt6_fill_node(arg->net,
2532 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2533 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
2534 prefix, 0, NLM_F_MULTI);
2535 }
2536
2537 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2538 {
2539 struct net *net = sock_net(in_skb->sk);
2540 struct nlattr *tb[RTA_MAX+1];
2541 struct rt6_info *rt;
2542 struct sk_buff *skb;
2543 struct rtmsg *rtm;
2544 struct flowi6 fl6;
2545 int err, iif = 0, oif = 0;
2546
2547 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2548 if (err < 0)
2549 goto errout;
2550
2551 err = -EINVAL;
2552 memset(&fl6, 0, sizeof(fl6));
2553
2554 if (tb[RTA_SRC]) {
2555 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2556 goto errout;
2557
2558 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
2559 }
2560
2561 if (tb[RTA_DST]) {
2562 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2563 goto errout;
2564
2565 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
2566 }
2567
2568 if (tb[RTA_IIF])
2569 iif = nla_get_u32(tb[RTA_IIF]);
2570
2571 if (tb[RTA_OIF])
2572 oif = nla_get_u32(tb[RTA_OIF]);
2573
2574 if (iif) {
2575 struct net_device *dev;
2576 int flags = 0;
2577
2578 dev = __dev_get_by_index(net, iif);
2579 if (!dev) {
2580 err = -ENODEV;
2581 goto errout;
2582 }
2583
2584 fl6.flowi6_iif = iif;
2585
2586 if (!ipv6_addr_any(&fl6.saddr))
2587 flags |= RT6_LOOKUP_F_HAS_SADDR;
2588
2589 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
2590 flags);
2591 } else {
2592 fl6.flowi6_oif = oif;
2593
2594 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
2595 }
2596
2597 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2598 if (!skb) {
2599 dst_release(&rt->dst);
2600 err = -ENOBUFS;
2601 goto errout;
2602 }
2603
2604 /* Reserve room for dummy headers, this skb can pass
2605 through good chunk of routing engine.
2606 */
2607 skb_reset_mac_header(skb);
2608 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2609
2610 skb_dst_set(skb, &rt->dst);
2611
2612 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
2613 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
2614 nlh->nlmsg_seq, 0, 0, 0);
2615 if (err < 0) {
2616 kfree_skb(skb);
2617 goto errout;
2618 }
2619
2620 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2621 errout:
2622 return err;
2623 }
2624
2625 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2626 {
2627 struct sk_buff *skb;
2628 struct net *net = info->nl_net;
2629 u32 seq;
2630 int err;
2631
2632 err = -ENOBUFS;
2633 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
2634
2635 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2636 if (!skb)
2637 goto errout;
2638
2639 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
2640 event, info->portid, seq, 0, 0, 0);
2641 if (err < 0) {
2642 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2643 WARN_ON(err == -EMSGSIZE);
2644 kfree_skb(skb);
2645 goto errout;
2646 }
2647 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
2648 info->nlh, gfp_any());
2649 return;
2650 errout:
2651 if (err < 0)
2652 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
2653 }
2654
2655 static int ip6_route_dev_notify(struct notifier_block *this,
2656 unsigned long event, void *data)
2657 {
2658 struct net_device *dev = (struct net_device *)data;
2659 struct net *net = dev_net(dev);
2660
2661 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2662 net->ipv6.ip6_null_entry->dst.dev = dev;
2663 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
2664 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2665 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
2666 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2667 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
2668 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
2669 #endif
2670 }
2671
2672 return NOTIFY_OK;
2673 }
2674
2675 /*
2676 * /proc
2677 */
2678
2679 #ifdef CONFIG_PROC_FS
2680
2681 struct rt6_proc_arg
2682 {
2683 char *buffer;
2684 int offset;
2685 int length;
2686 int skip;
2687 int len;
2688 };
2689
2690 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2691 {
2692 struct seq_file *m = p_arg;
2693 struct neighbour *n;
2694
2695 seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
2696
2697 #ifdef CONFIG_IPV6_SUBTREES
2698 seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
2699 #else
2700 seq_puts(m, "00000000000000000000000000000000 00 ");
2701 #endif
2702 n = rt->n;
2703 if (n) {
2704 seq_printf(m, "%pi6", n->primary_key);
2705 } else {
2706 seq_puts(m, "00000000000000000000000000000000");
2707 }
2708 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2709 rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2710 rt->dst.__use, rt->rt6i_flags,
2711 rt->dst.dev ? rt->dst.dev->name : "");
2712 return 0;
2713 }
2714
2715 static int ipv6_route_show(struct seq_file *m, void *v)
2716 {
2717 struct net *net = (struct net *)m->private;
2718 fib6_clean_all_ro(net, rt6_info_route, 0, m);
2719 return 0;
2720 }
2721
2722 static int ipv6_route_open(struct inode *inode, struct file *file)
2723 {
2724 return single_open_net(inode, file, ipv6_route_show);
2725 }
2726
2727 static const struct file_operations ipv6_route_proc_fops = {
2728 .owner = THIS_MODULE,
2729 .open = ipv6_route_open,
2730 .read = seq_read,
2731 .llseek = seq_lseek,
2732 .release = single_release_net,
2733 };
2734
2735 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2736 {
2737 struct net *net = (struct net *)seq->private;
2738 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2739 net->ipv6.rt6_stats->fib_nodes,
2740 net->ipv6.rt6_stats->fib_route_nodes,
2741 net->ipv6.rt6_stats->fib_rt_alloc,
2742 net->ipv6.rt6_stats->fib_rt_entries,
2743 net->ipv6.rt6_stats->fib_rt_cache,
2744 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
2745 net->ipv6.rt6_stats->fib_discarded_routes);
2746
2747 return 0;
2748 }
2749
2750 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2751 {
2752 return single_open_net(inode, file, rt6_stats_seq_show);
2753 }
2754
2755 static const struct file_operations rt6_stats_seq_fops = {
2756 .owner = THIS_MODULE,
2757 .open = rt6_stats_seq_open,
2758 .read = seq_read,
2759 .llseek = seq_lseek,
2760 .release = single_release_net,
2761 };
2762 #endif /* CONFIG_PROC_FS */
2763
2764 #ifdef CONFIG_SYSCTL
2765
2766 static
2767 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
2768 void __user *buffer, size_t *lenp, loff_t *ppos)
2769 {
2770 struct net *net;
2771 int delay;
2772 if (!write)
2773 return -EINVAL;
2774
2775 net = (struct net *)ctl->extra1;
2776 delay = net->ipv6.sysctl.flush_delay;
2777 proc_dointvec(ctl, write, buffer, lenp, ppos);
2778 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2779 return 0;
2780 }
2781
2782 ctl_table ipv6_route_table_template[] = {
2783 {
2784 .procname = "flush",
2785 .data = &init_net.ipv6.sysctl.flush_delay,
2786 .maxlen = sizeof(int),
2787 .mode = 0200,
2788 .proc_handler = ipv6_sysctl_rtcache_flush
2789 },
2790 {
2791 .procname = "gc_thresh",
2792 .data = &ip6_dst_ops_template.gc_thresh,
2793 .maxlen = sizeof(int),
2794 .mode = 0644,
2795 .proc_handler = proc_dointvec,
2796 },
2797 {
2798 .procname = "max_size",
2799 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2800 .maxlen = sizeof(int),
2801 .mode = 0644,
2802 .proc_handler = proc_dointvec,
2803 },
2804 {
2805 .procname = "gc_min_interval",
2806 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2807 .maxlen = sizeof(int),
2808 .mode = 0644,
2809 .proc_handler = proc_dointvec_jiffies,
2810 },
2811 {
2812 .procname = "gc_timeout",
2813 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2814 .maxlen = sizeof(int),
2815 .mode = 0644,
2816 .proc_handler = proc_dointvec_jiffies,
2817 },
2818 {
2819 .procname = "gc_interval",
2820 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2821 .maxlen = sizeof(int),
2822 .mode = 0644,
2823 .proc_handler = proc_dointvec_jiffies,
2824 },
2825 {
2826 .procname = "gc_elasticity",
2827 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2828 .maxlen = sizeof(int),
2829 .mode = 0644,
2830 .proc_handler = proc_dointvec,
2831 },
2832 {
2833 .procname = "mtu_expires",
2834 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2835 .maxlen = sizeof(int),
2836 .mode = 0644,
2837 .proc_handler = proc_dointvec_jiffies,
2838 },
2839 {
2840 .procname = "min_adv_mss",
2841 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2842 .maxlen = sizeof(int),
2843 .mode = 0644,
2844 .proc_handler = proc_dointvec,
2845 },
2846 {
2847 .procname = "gc_min_interval_ms",
2848 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2849 .maxlen = sizeof(int),
2850 .mode = 0644,
2851 .proc_handler = proc_dointvec_ms_jiffies,
2852 },
2853 { }
2854 };
2855
2856 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2857 {
2858 struct ctl_table *table;
2859
2860 table = kmemdup(ipv6_route_table_template,
2861 sizeof(ipv6_route_table_template),
2862 GFP_KERNEL);
2863
2864 if (table) {
2865 table[0].data = &net->ipv6.sysctl.flush_delay;
2866 table[0].extra1 = net;
2867 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
2868 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2869 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2870 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2871 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2872 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2873 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2874 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2875 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2876 }
2877
2878 return table;
2879 }
2880 #endif
2881
2882 static int __net_init ip6_route_net_init(struct net *net)
2883 {
2884 int ret = -ENOMEM;
2885
2886 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
2887 sizeof(net->ipv6.ip6_dst_ops));
2888
2889 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
2890 goto out_ip6_dst_ops;
2891
2892 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
2893 sizeof(*net->ipv6.ip6_null_entry),
2894 GFP_KERNEL);
2895 if (!net->ipv6.ip6_null_entry)
2896 goto out_ip6_dst_entries;
2897 net->ipv6.ip6_null_entry->dst.path =
2898 (struct dst_entry *)net->ipv6.ip6_null_entry;
2899 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2900 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
2901 ip6_template_metrics, true);
2902
2903 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2904 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
2905 sizeof(*net->ipv6.ip6_prohibit_entry),
2906 GFP_KERNEL);
2907 if (!net->ipv6.ip6_prohibit_entry)
2908 goto out_ip6_null_entry;
2909 net->ipv6.ip6_prohibit_entry->dst.path =
2910 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
2911 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2912 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
2913 ip6_template_metrics, true);
2914
2915 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
2916 sizeof(*net->ipv6.ip6_blk_hole_entry),
2917 GFP_KERNEL);
2918 if (!net->ipv6.ip6_blk_hole_entry)
2919 goto out_ip6_prohibit_entry;
2920 net->ipv6.ip6_blk_hole_entry->dst.path =
2921 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
2922 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
2923 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
2924 ip6_template_metrics, true);
2925 #endif
2926
2927 net->ipv6.sysctl.flush_delay = 0;
2928 net->ipv6.sysctl.ip6_rt_max_size = 4096;
2929 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2930 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2931 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2932 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2933 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2934 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2935
2936 net->ipv6.ip6_rt_gc_expire = 30*HZ;
2937
2938 ret = 0;
2939 out:
2940 return ret;
2941
2942 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2943 out_ip6_prohibit_entry:
2944 kfree(net->ipv6.ip6_prohibit_entry);
2945 out_ip6_null_entry:
2946 kfree(net->ipv6.ip6_null_entry);
2947 #endif
2948 out_ip6_dst_entries:
2949 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
2950 out_ip6_dst_ops:
2951 goto out;
2952 }
2953
2954 static void __net_exit ip6_route_net_exit(struct net *net)
2955 {
2956 kfree(net->ipv6.ip6_null_entry);
2957 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2958 kfree(net->ipv6.ip6_prohibit_entry);
2959 kfree(net->ipv6.ip6_blk_hole_entry);
2960 #endif
2961 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
2962 }
2963
2964 static int __net_init ip6_route_net_init_late(struct net *net)
2965 {
2966 #ifdef CONFIG_PROC_FS
2967 proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
2968 proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2969 #endif
2970 return 0;
2971 }
2972
2973 static void __net_exit ip6_route_net_exit_late(struct net *net)
2974 {
2975 #ifdef CONFIG_PROC_FS
2976 proc_net_remove(net, "ipv6_route");
2977 proc_net_remove(net, "rt6_stats");
2978 #endif
2979 }
2980
2981 static struct pernet_operations ip6_route_net_ops = {
2982 .init = ip6_route_net_init,
2983 .exit = ip6_route_net_exit,
2984 };
2985
2986 static int __net_init ipv6_inetpeer_init(struct net *net)
2987 {
2988 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2989
2990 if (!bp)
2991 return -ENOMEM;
2992 inet_peer_base_init(bp);
2993 net->ipv6.peers = bp;
2994 return 0;
2995 }
2996
2997 static void __net_exit ipv6_inetpeer_exit(struct net *net)
2998 {
2999 struct inet_peer_base *bp = net->ipv6.peers;
3000
3001 net->ipv6.peers = NULL;
3002 inetpeer_invalidate_tree(bp);
3003 kfree(bp);
3004 }
3005
3006 static struct pernet_operations ipv6_inetpeer_ops = {
3007 .init = ipv6_inetpeer_init,
3008 .exit = ipv6_inetpeer_exit,
3009 };
3010
3011 static struct pernet_operations ip6_route_net_late_ops = {
3012 .init = ip6_route_net_init_late,
3013 .exit = ip6_route_net_exit_late,
3014 };
3015
3016 static struct notifier_block ip6_route_dev_notifier = {
3017 .notifier_call = ip6_route_dev_notify,
3018 .priority = 0,
3019 };
3020
3021 int __init ip6_route_init(void)
3022 {
3023 int ret;
3024
3025 ret = -ENOMEM;
3026 ip6_dst_ops_template.kmem_cachep =
3027 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3028 SLAB_HWCACHE_ALIGN, NULL);
3029 if (!ip6_dst_ops_template.kmem_cachep)
3030 goto out;
3031
3032 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3033 if (ret)
3034 goto out_kmem_cache;
3035
3036 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3037 if (ret)
3038 goto out_dst_entries;
3039
3040 ret = register_pernet_subsys(&ip6_route_net_ops);
3041 if (ret)
3042 goto out_register_inetpeer;
3043
3044 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3045
3046 /* Registering of the loopback is done before this portion of code,
3047 * the loopback reference in rt6_info will not be taken, do it
3048 * manually for init_net */
3049 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3050 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3051 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3052 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3053 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3054 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3055 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3056 #endif
3057 ret = fib6_init();
3058 if (ret)
3059 goto out_register_subsys;
3060
3061 ret = xfrm6_init();
3062 if (ret)
3063 goto out_fib6_init;
3064
3065 ret = fib6_rules_init();
3066 if (ret)
3067 goto xfrm6_init;
3068
3069 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3070 if (ret)
3071 goto fib6_rules_init;
3072
3073 ret = -ENOBUFS;
3074 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3075 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3076 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3077 goto out_register_late_subsys;
3078
3079 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3080 if (ret)
3081 goto out_register_late_subsys;
3082
3083 out:
3084 return ret;
3085
3086 out_register_late_subsys:
3087 unregister_pernet_subsys(&ip6_route_net_late_ops);
3088 fib6_rules_init:
3089 fib6_rules_cleanup();
3090 xfrm6_init:
3091 xfrm6_fini();
3092 out_fib6_init:
3093 fib6_gc_cleanup();
3094 out_register_subsys:
3095 unregister_pernet_subsys(&ip6_route_net_ops);
3096 out_register_inetpeer:
3097 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3098 out_dst_entries:
3099 dst_entries_destroy(&ip6_dst_blackhole_ops);
3100 out_kmem_cache:
3101 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3102 goto out;
3103 }
3104
3105 void ip6_route_cleanup(void)
3106 {
3107 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3108 unregister_pernet_subsys(&ip6_route_net_late_ops);
3109 fib6_rules_cleanup();
3110 xfrm6_fini();
3111 fib6_gc_cleanup();
3112 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3113 unregister_pernet_subsys(&ip6_route_net_ops);
3114 dst_entries_destroy(&ip6_dst_blackhole_ops);
3115 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3116 }
kernel source for telekom puls (alcatel/mediatek)