SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ipv6/route.c

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