git.oblomov.eu Git - linux-2.6/blob - net/ipv6/route.c

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