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