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

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