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