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