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

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