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