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