net/ipv6/route.c

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