net/ipv6/route.c

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