net/ipv6/route.c

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