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

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